Welcome to the "trac"-ing site of soap4r!
[soap4r] [httpclient] [openpgp4u] [pkcs1] [logger] [csv] [vtr]

Changeset 1597

Show
Ignore:
Timestamp:
07/25/05 00:01:57 (3 years ago)
Author:
nahi
Message:

let external CES configuable. ex. clientsoap.mapping.external_ces? = 'SJIS'. $KCODE is used by default.

external CES ::= CES used in Ruby object of client and server
internal CES ::= CES used in SOAP/OM

closes #133.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/mapping/factory.rb

    r1547 r1597  
    8888    end 
    8989    begin 
    90       unless XSD::Charset.is_ces(obj, $KCODE) 
    91         return nil 
    92       end 
    93       encoded = XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) 
     90      unless XSD::Charset.is_ces(obj, Thread.current[:SOAPExternalCES]) 
     91        return nil 
     92      end 
     93      encoded = XSD::Charset.encoding_conv(obj, 
     94        Thread.current[:SOAPExternalCES], XSD::Charset.encoding) 
    9495      soap_obj = soap_class.new(encoded) 
    9596    rescue XSD::ValueSpaceError 
    …… 
    102103  def soap2obj(obj_class, node, info, map) 
    103104    obj = Mapping.create_empty_object(obj_class) 
    104     decoded = XSD::Charset.encoding_conv(node.data, XSD::Charset.encoding, $KCODE) 
     105    decoded = XSD::Charset.encoding_conv(node.data, XSD::Charset.encoding, 
     106      Thread.current[:SOAPExternalCES]) 
    105107    obj.replace(decoded) 
    106108    mark_unmarshalled_obj(node, obj) 

  • trunk/lib/soap/mapping/mapping.rb

    r1590 r1597  
    2121 
    2222 
    23   # TraverseSupport breaks Thread.current[:SOAPMarshalDataKey]. 
     23  # TraverseSupport breaks following thread variables. 
     24  #   Thread.current[:SOAPMarshalDataKey] 
     25  #   Thread.current[:SOAPExternalCES] 
    2426  module TraverseSupport 
    2527    def mark_marshalled_obj(obj, soap_obj) 
    …… 
    3638 
    3739 
    38   def self.obj2soap(obj, registry = nil, type = nil) 
    39     registry ||= Mapping::DefaultRegistry 
    40     Thread.current[:SOAPMarshalDataKey] = {} 
    41     soap_obj = _obj2soap(obj, registry, type) 
    42     Thread.current[:SOAPMarshalDataKey] = nil 
     40  EMPTY_OPT = {} 
     41  def self.obj2soap(obj, registry = nil, type = nil, opt = EMPTY_OPT) 
     42    registry ||= Mapping::DefaultRegistry 
     43    prekey = Thread.current[:SOAPMarshalDataKey] 
     44    preces = Thread.current[:SOAPExternalCES] 
     45    begin 
     46      Thread.current[:SOAPMarshalDataKey] = {} 
     47      Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     48      soap_obj = _obj2soap(obj, registry, type) 
     49    ensure 
     50      Thread.current[:SOAPMarshalDataKey] = prekey 
     51      Thread.current[:SOAPExternalCES] = preces 
     52    end 
    4353    soap_obj 
    4454  end 
    4555 
    46   def self.soap2obj(node, registry = nil, klass = nil) 
    47     registry ||= Mapping::DefaultRegistry 
    48     Thread.current[:SOAPMarshalDataKey] = {} 
    49     obj = _soap2obj(node, registry, klass) 
    50     Thread.current[:SOAPMarshalDataKey] = nil 
     56  def self.soap2obj(node, registry = nil, klass = nil, opt = EMPTY_OPT) 
     57    registry ||= Mapping::DefaultRegistry 
     58    prekey = Thread.current[:SOAPMarshalDataKey] 
     59    preces = Thread.current[:SOAPExternalCES] 
     60    begin 
     61      Thread.current[:SOAPMarshalDataKey] = {} 
     62      Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     63      obj = _soap2obj(node, registry, klass) 
     64    ensure 
     65      Thread.current[:SOAPMarshalDataKey] = prekey 
     66      Thread.current[:SOAPExternalCES] = preces 
     67    end 
    5168    obj 
    5269  end 
    5370 
    54   def self.ary2soap(ary, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil) 
     71  def self.ary2soap(ary, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) 
    5572    registry ||= Mapping::DefaultRegistry 
    5673    type = XSD::QName.new(type_ns, typename) 
    5774    soap_ary = SOAPArray.new(ValueArrayName, 1, type) 
    58     Thread.current[:SOAPMarshalDataKey] = {} 
    59     ary.each do |ele| 
    60       soap_ary.add(_obj2soap(ele, registry, type)) 
    61     end 
    62     Thread.current[:SOAPMarshalDataKey] = nil 
     75    prekey = Thread.current[:SOAPMarshalDataKey] 
     76    preces = Thread.current[:SOAPExternalCES] 
     77    begin 
     78      Thread.current[:SOAPMarshalDataKey] = {} 
     79      Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     80      ary.each do |ele| 
     81        soap_ary.add(_obj2soap(ele, registry, type)) 
     82      end 
     83    ensure 
     84      Thread.current[:SOAPMarshalDataKey] = prekey 
     85      Thread.current[:SOAPExternalCES] = preces 
     86    end 
    6387    soap_ary 
    6488  end 
    6589 
    66   def self.ary2md(ary, rank, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil) 
     90  def self.ary2md(ary, rank, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) 
    6791    registry ||= Mapping::DefaultRegistry 
    6892    type = XSD::QName.new(type_ns, typename) 
    6993    md_ary = SOAPArray.new(ValueArrayName, rank, type) 
    70     Thread.current[:SOAPMarshalDataKey] = {} 
    71     add_md_ary(md_ary, ary, [], registry) 
    72     Thread.current[:SOAPMarshalDataKey] = nil 
     94    prekey = Thread.current[:SOAPMarshalDataKey] 
     95    preces = Thread.current[:SOAPExternalCES] 
     96    begin 
     97      Thread.current[:SOAPMarshalDataKey] = {} 
     98      Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE 
     99      add_md_ary(md_ary, ary, [], registry) 
     100    ensure 
     101      Thread.current[:SOAPMarshalDataKey] = prekey 
     102      Thread.current[:SOAPExternalCES] = preces 
     103    end 
    73104    md_ary 
    74105  end 

  • trunk/lib/soap/mapping/wsdlencodedregistry.rb

    r1581 r1597  
    150150    soap_obj = nil 
    151151    if type <= XSD::XSDString 
    152       soap_obj = type.new(XSD::Charset.is_ces(obj, $KCODE) ? 
    153         XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) : obj) 
     152      str = XSD::Charset.encoding_conv(obj, Thread.current[:SOAPExternalCES], 
     153        XSD::Charset.encoding) 
     154      soap_obj = type.new(str) 
    154155      mark_marshalled_obj(obj, soap_obj) 
    155156    else 

  • trunk/lib/soap/mapping/wsdlliteralregistry.rb

    r1584 r1597  
    239239    soap_obj = nil 
    240240    if type <= XSD::XSDString 
    241       soap_obj = type.new(XSD::Charset.is_ces(obj, $KCODE) ? 
    242         XSD::Charset.encoding_conv(obj, $KCODE, XSD::Charset.encoding) : obj) 
     241      str = XSD::Charset.encoding_conv(obj, Thread.current[:SOAPExternalCES], 
     242        XSD::Charset.encoding) 
     243      soap_obj = type.new(str) 
    243244    else 
    244245      soap_obj = type.new(obj) 

  • trunk/lib/soap/rpc/proxy.rb

    r1588 r1597  
    110110 
    111111  def invoke(req_header, req_body, opt = nil) 
    112     opt ||= create_options 
     112    opt ||= create_encoding_opt 
    113113    route(req_header, req_body, opt, opt) 
    114114  end 
    …… 
    118118      raise MethodDefinitionError, "method: #{name} not defined" 
    119119    end 
     120    mapping_opt = create_mapping_opt 
    120121    req_header = create_request_header 
    121122    req_body = SOAPBody.new( 
    122       op_info.request_body(params, @mapping_registry, @literal_mapping_registry) 
     123      op_info.request_body(params, @mapping_registry, 
     124        @literal_mapping_registry, mapping_opt) 
    123125    ) 
    124     reqopt = create_options( 
     126    reqopt = create_encoding_opt( 
    125127      :soapaction => op_info.soapaction || @soapaction, 
    126128      :envelopenamespace => @options["soap.envelope.requestnamespace"], 
    …… 
    129131      :attributeformdefault => op_info.attributeformdefault 
    130132    ) 
    131     resopt = create_options( 
     133    resopt = create_encoding_opt( 
    132134      :envelopenamespace => @options["soap.envelope.responsenamespace"], 
    133135      :default_encodingstyle => op_info.response_default_encodingstyle, 
    …… 
    143145      op_info.raise_fault(e, @mapping_registry, @literal_mapping_registry) 
    144146    end 
    145     op_info.response_obj(env.body, @mapping_registry, @literal_mapping_registry) 
     147    op_info.response_obj(env.body, @mapping_registry, 
     148      @literal_mapping_registry, mapping_opt) 
    146149  end 
    147150 
    …… 
    246249  end 
    247250 
    248   def create_options(hash = nil) 
     251  def create_encoding_opt(hash = nil) 
    249252    opt = {} 
    250253    opt[:default_encodingstyle] = @default_encodingstyle 
    …… 
    252255    opt[:generate_explicit_type] = @generate_explicit_type 
    253256    opt[:no_indent] = @options["soap.envelope.no_indent"] 
     257    opt.update(hash) if hash 
     258    opt 
     259  end 
     260 
     261  def create_mapping_opt(hash = nil) 
     262    opt = { 
     263      :external_ces => @options["soap.mapping.external_ces"] 
     264    } 
    254265    opt.update(hash) if hash 
    255266    opt 
    …… 
    319330    end 
    320331 
    321     def request_body(values, mapping_registry, literal_mapping_registry) 
     332    def request_body(values, mapping_registry, literal_mapping_registry, opt) 
    322333      if @request_style == :rpc 
    323         request_rpc(values, mapping_registry, literal_mapping_registry) 
    324       else 
    325         request_doc(values, mapping_registry, literal_mapping_registry) 
    326       end 
    327     end 
    328  
    329     def response_obj(body, mapping_registry, literal_mapping_registry) 
     334        request_rpc(values, mapping_registry, literal_mapping_registry, opt) 
     335      else 
     336        request_doc(values, mapping_registry, literal_mapping_registry, opt) 
     337      end 
     338    end 
     339 
     340    def response_obj(body, mapping_registry, literal_mapping_registry, opt) 
    330341      if @response_style == :rpc 
    331         response_rpc(body, mapping_registry, literal_mapping_registry) 
    332       else 
    333         response_doc(body, mapping_registry, literal_mapping_registry) 
     342        response_rpc(body, mapping_registry, literal_mapping_registry, opt) 
     343      else 
     344        response_doc(body, mapping_registry, literal_mapping_registry, opt) 
    334345      end 
    335346    end 
    …… 
    357368    end 
    358369 
    359     def request_rpc(values, mapping_registry, literal_mapping_registry) 
     370    def request_rpc(values, mapping_registry, literal_mapping_registry, opt) 
    360371      if @request_use == :encoded 
    361         request_rpc_enc(values, mapping_registry) 
    362       else 
    363         request_rpc_lit(values, literal_mapping_registry) 
    364       end 
    365     end 
    366  
    367     def request_doc(values, mapping_registry, literal_mapping_registry) 
     372        request_rpc_enc(values, mapping_registry, opt) 
     373      else 
     374        request_rpc_lit(values, literal_mapping_registry, opt) 
     375      end 
     376    end 
     377 
     378    def request_doc(values, mapping_registry, literal_mapping_registry, opt) 
    368379      if @request_use == :encoded 
    369         request_doc_enc(values, mapping_registry) 
    370       else 
    371         request_doc_lit(values, literal_mapping_registry) 
    372       end 
    373     end 
    374  
    375     def request_rpc_enc(values, mapping_registry) 
     380        request_doc_enc(values, mapping_registry, opt) 
     381      else 
     382        request_doc_lit(values, literal_mapping_registry, opt) 
     383      end 
     384    end 
     385 
     386    def request_rpc_enc(values, mapping_registry, opt) 
    376387      method = @rpc_method_factory.dup 
    377388      names = method.input_params 
    378389      obj = create_request_obj(names, values) 
    379       soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname) 
     390      soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname, opt) 
    380391      method.set_param(soap) 
    381392      method 
    382393    end 
    383394 
    384     def request_rpc_lit(values, mapping_registry) 
     395    def request_rpc_lit(values, mapping_registry, opt) 
    385396      method = @rpc_method_factory.dup 
    386397      params = {} 
    …… 
    388399      method.input_params.each do |name| 
    389400        params[name] = Mapping.obj2soap(values[idx], mapping_registry,  
    390           XSD::QName.new(nil, name)) 
     401          XSD::QName.new(nil, name), opt) 
    391402        idx += 1 
    392403      end 
    …… 
    395406    end 
    396407 
    397     def request_doc_enc(values, mapping_registry) 
     408    def request_doc_enc(values, mapping_registry, opt) 
    398409      (0...values.size).collect { |idx| 
    399         ele = Mapping.obj2soap(values[idx], mapping_registry) 
     410        ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt) 
    400411        ele.elename = @doc_request_qnames[idx] 
    401412        ele 
    …… 
    403414    end 
    404415 
    405     def request_doc_lit(values, mapping_registry) 
     416    def request_doc_lit(values, mapping_registry, opt) 
    406417      (0...values.size).collect { |idx| 
    407418        ele = Mapping.obj2soap(values[idx], mapping_registry, 
    408           @doc_request_qnames[idx]) 
     419          @doc_request_qnames[idx], opt) 
    409420        ele.encodingstyle = LiteralNamespace 
    410421        if ele.respond_to?(:qualified) 
    …… 
    415426    end 
    416427 
    417     def response_rpc(body, mapping_registry, literal_mapping_registry) 
     428    def response_rpc(body, mapping_registry, literal_mapping_registry, opt) 
    418429      if @response_use == :encoded 
    419         response_rpc_enc(body, mapping_registry) 
    420       else 
    421         response_rpc_lit(body, literal_mapping_registry) 
    422       end 
    423     end 
    424  
    425     def response_doc(body, mapping_registry, literal_mapping_registry) 
     430        response_rpc_enc(body, mapping_registry, opt) 
     431      else 
     432        response_rpc_lit(body, literal_mapping_registry, opt) 
     433      end 
     434    end 
     435 
     436    def response_doc(body, mapping_registry, literal_mapping_registry, opt) 
    426437      if @response_use == :encoded 
    427         return *response_doc_enc(body, mapping_registry) 
    428       else 
    429         return *response_doc_lit(body, literal_mapping_registry) 
    430       end 
    431     end 
    432  
    433     def response_rpc_enc(body, mapping_registry) 
     438        return *response_doc_enc(body, mapping_registry, opt) 
     439      else 
     440        return *response_doc_lit(body, literal_mapping_registry, opt) 
     441      end 
     442    end 
     443 
     444    def response_rpc_enc(body, mapping_registry, opt) 
    434445      ret = nil 
    435446      if body.response 
    436447        ret = Mapping.soap2obj(body.response, mapping_registry, 
    437           @rpc_method_factory.retval_class_name) 
     448          @rpc_method_factory.retval_class_name, opt) 
    438449      end 
    439450      if body.outparams 
    440451        outparams = body.outparams.collect { |outparam| 
    441           Mapping.soap2obj(outparam, mapping_registry) 
     452          Mapping.soap2obj(outparam, mapping_registry, nil, opt) 
    442453        } 
    443454        [ret].concat(outparams) 
    …… 
    447458    end 
    448459 
    449     def response_rpc_lit(body, mapping_registry) 
     460    def response_rpc_lit(body, mapping_registry, opt) 
    450461      body.root_node.collect { |key, value| 
    451462        Mapping.soap2obj(value, mapping_registry, 
    452           @rpc_method_factory.retval_class_name) 
     463          @rpc_method_factory.retval_class_name, opt) 
    453464      } 
    454465    end 
    455466 
    456     def response_doc_enc(body, mapping_registry) 
     467    def response_doc_enc(body, mapping_registry, opt) 
    457468      body.collect { |key, value| 
    458         Mapping.soap2obj(value, mapping_registry) 
     469        Mapping.soap2obj(value, mapping_registry, nil, opt) 
    459470      } 
    460471    end 
    461472 
    462     def response_doc_lit(body, mapping_registry) 
     473    def response_doc_lit(body, mapping_registry, opt) 
    463474      body.collect { |key, value| 
    464475        Mapping.soap2obj(value, mapping_registry) 

  • trunk/lib/soap/rpc/router.rb

    r1584 r1597  
    2929  attr_accessor :literal_mapping_registry 
    3030  attr_accessor :generate_explicit_type 
     31  attr_accessor :external_ces 
    3132 
    3233  def initialize(actor) 
    …… 
    3637    @literal_mapping_registry = ::SOAP::Mapping::WSDLLiteralRegistry.new 
    3738    @generate_explicit_type = true 
     39    @external_ces = nil 
    3840    @operation_by_soapaction = {} 
    3941    @operation_by_qname = {} 
    …… 
    164166    begin 
    165167      soap_response = 
    166         op.call(env.body, @mapping_registry, @literal_mapping_registry) 
     168        op.call(env.body, @mapping_registry, @literal_mapping_registry, 
     169          create_mapping_opt) 
    167170      default_encodingstyle = op.response_default_encodingstyle 
    168171    rescue Exception 
    …… 
    323326      SOAPString.new(@actor), 
    324327      Mapping.obj2soap(detail, @mapping_registry)) 
     328  end 
     329 
     330  def create_mapping_opt 
     331    { :external_ces => @external_ces } 
    325332  end 
    326333 
    …… 
    351358      else 
    352359        @doc_request_qnames = [] 
     360        @doc_request_qualified = [] 
    353361        @doc_response_qnames = [] 
    354         param_def.each do |inout, paramname, typeinfo| 
     362        @doc_response_qualified = [] 
     363        param_def.each do |inout, paramname, typeinfo, eleinfo| 
    355364          klass, nsdef, namedef = typeinfo 
     365          qualified = eleinfo 
    356366          case inout 
    357367          when SOAPMethod::IN 
    358368            @doc_request_qnames << XSD::QName.new(nsdef, namedef) 
     369            @doc_request_qualified << qualified 
    359370          when SOAPMethod::OUT 
    360371            @doc_response_qnames << XSD::QName.new(nsdef, namedef) 
     372            @doc_response_qualified << qualified 
    361373          else 
    362374            raise ArgumentError.new( 
    …… 
    375387    end 
    376388 
    377     def call(body, mapping_registry, literal_mapping_registry) 
     389    def call(body, mapping_registry, literal_mapping_registry, opt) 
    378390      if @request_style == :rpc 
    379         values = request_rpc(body, mapping_registry, literal_mapping_registry) 
    380       else 
    381         values = request_document(body, mapping_registry, literal_mapping_registry) 
     391        values = request_rpc(body, mapping_registry, literal_mapping_registry, 
     392          opt) 
     393      else 
     394        values = request_document(body, mapping_registry, 
     395          literal_mapping_registry, opt) 
    382396      end 
    383397      result = receiver.method(@name.intern).call(*values) 
    384398      return result if result.is_a?(SOAPFault) 
    385399      if @response_style == :rpc 
    386         response_rpc(result, mapping_registry, literal_mapping_registry) 
    387       else 
    388         response_doc(result, mapping_registry, literal_mapping_registry) 
     400        response_rpc(result, mapping_registry, literal_mapping_registry, opt) 
     401      else 
     402        response_doc(result, mapping_registry, literal_mapping_registry, opt) 
    389403      end 
    390404    end 
    …… 
    396410    end 
    397411 
    398     def request_rpc(body, mapping_registry, literal_mapping_registry) 
     412    def request_rpc(body, mapping_registry, literal_mapping_registry, opt) 
    399413      request = body.request 
    400414      unless request.is_a?(SOAPStruct) 
    …… 
    402416      end 
    403417      if @request_use == :encoded 
    404         request_rpc_enc(request, mapping_registry) 
    405       else 
    406         request_rpc_lit(request, literal_mapping_registry) 
    407       end 
    408     end 
    409  
    410     def request_document(body, mapping_registry, literal_mapping_registry) 
     418        request_rpc_enc(request, mapping_registry, opt) 
     419      else 
     420        request_rpc_lit(request, literal_mapping_registry, opt) 
     421      end 
     422    end 
     423 
     424    def request_document(body, mapping_registry, literal_mapping_registry, opt) 
    411425      # ToDo: compare names with @doc_request_qnames 
    412426      if @request_use == :encoded 
    413         request_doc_enc(body, mapping_registry) 
    414       else 
    415         request_doc_lit(body, literal_mapping_registry) 
    416       end 
    417     end 
    418  
    419     def request_rpc_enc(request, mapping_registry) 
    420       param = Mapping.soap2obj(request, mapping_registry) 
     427        request_doc_enc(body, mapping_registry, opt) 
     428      else 
     429        request_doc_lit(body, literal_mapping_registry, opt) 
     430      end 
     431    end 
     432 
     433    def request_rpc_enc(request, mapping_registry, opt) 
     434      param = Mapping.soap2obj(request, mapping_registry, nil, opt) 
    421435      request.collect { |key, value| 
    422436        param[key] 
    …… 
    424438    end 
    425439 
    426     def request_rpc_lit(request, mapping_registry) 
     440    def request_rpc_lit(request, mapping_registry, opt) 
    427441      request.collect { |key, value| 
    428         Mapping.soap2obj(value, mapping_registry) 
     442        Mapping.soap2obj(value, mapping_registry, nil, opt) 
    429443      } 
    430444    end 
    431445 
    432     def request_doc_enc(body, mapping_registry) 
     446    def request_doc_enc(body, mapping_registry, opt) 
    433447      body.collect { |key, value| 
    434         Mapping.soap2obj(value, mapping_registry) 
     448        Mapping.soap2obj(value, mapping_registry, nil, opt) 
    435449      } 
    436450    end 
    437451 
    438     def request_doc_lit(body, mapping_registry) 
     452    def request_doc_lit(body, mapping_registry, opt) 
    439453      body.collect { |key, value| 
    440         Mapping.soap2obj(value, mapping_registry) 
     454        Mapping.soap2obj(value, mapping_registry, nil, opt) 
    441455      } 
    442456    end 
    443457 
    444     def response_rpc(result, mapping_registry, literal_mapping_registry) 
     458    def response_rpc(result, mapping_registry, literal_mapping_registry, opt) 
    445459      if @response_use == :encoded 
    446         response_rpc_enc(result, mapping_registry) 
    447       else 
    448         response_rpc_lit(result, literal_mapping_registry) 
     460        response_rpc_enc(result, mapping_registry, opt) 
     461      else 
     462        response_rpc_lit(result, literal_mapping_registry, opt) 
    449463      end 
    450464    end 
    451465     
    452     def response_doc(result, mapping_registry, literal_mapping_registry) 
     466    def response_doc(result, mapping_registry, literal_mapping_registry, opt) 
    453467      if @doc_response_qnames.size == 1 and !result.is_a?(Array) 
    454468        result = [result] 
    …… 
    459473      end 
    460474      if @response_use == :encoded 
    461         response_doc_enc(result, mapping_registry) 
    462       else 
    463         response_doc_lit(result, literal_mapping_registry) 
    464       end 
    465     end 
    466  
    467     def response_rpc_enc(result, mapping_registry) 
    468       soap_response = 
    469         @rpc_method_factory.create_method_response(@rpc_response_qname) 
    470       if soap_response.have_outparam? 
    471         unless result.is_a?(Array) 
    472           raise RPCRoutingError.new("out parameter was not returned") 
    473         end 
    474         outparams = {} 
    475         i = 1 
    476         soap_response.output_params.each do |outparam| 
    477           outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry) 
    478           i += 1 
    479         end 
    480         soap_response.set_outparam(outparams) 
    481         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry) 
    482       else 
    483         soap_response.retval = Mapping.obj2soap(result, mapping_registry) 
    484       end 
    485       soap_response 
    486     end 
    487  
    488     def response_rpc_lit(result, mapping_registry) 
     475        response_doc_enc(result, mapping_registry, opt) 
     476      else 
     477        response_doc_lit(result, literal_mapping_registry, opt) 
     478      end 
     479    end 
     480 
     481    def response_rpc_enc(result, mapping_registry, opt) 
    489482      soap_response = 
    490483        @rpc_method_factory.create_method_response(@rpc_response_qname) 
    …… 
    497490        soap_response.output_params.each do |outparam| 
    498491          outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry, 
    499             XSD::QName.new(nil, outparam)) 
     492            nil, opt) 
    500493          i += 1 
    501494        end 
    502495        soap_response.set_outparam(outparams) 
    503496        soap_response.retval = Mapping.obj2soap(result[0], mapping_registry, 
    504           XSD::QName.new(nil, soap_response.elename)) 
     497          nil, opt) 
     498      else 
     499        soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil, 
     500          opt) 
     501      end 
     502      soap_response 
     503    end 
     504 
     505    def response_rpc_lit(result, mapping_registry, opt) 
     506      soap_response = 
     507        @rpc_method_factory.create_method_response(@rpc_response_qname) 
     508      if soap_response.have_outparam? 
     509        unless result.is_a?(Array) 
     510          raise RPCRoutingError.new("out parameter was not returned") 
     511        end 
     512        outparams = {} 
     513        i = 1 
     514        soap_response.output_params.each do |outparam| 
     515          outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry, 
     516            XSD::QName.new(nil, outparam), opt) 
     517          i += 1 
     518        end 
     519        soap_response.set_outparam(outparams) 
     520        soap_response.retval = Mapping.obj2soap(result[0], mapping_registry, 
     521          XSD::QName.new(nil, soap_response.elename), opt) 
    505522      else 
    506523        soap_response.retval = Mapping.obj2soap(result, mapping_registry, 
    507           XSD::QName.new(nil, soap_response.elename)) 
     524          XSD::QName.new(nil, soap_response.elename), opt) 
    508525      end 
    509526      soap_response 
    510527    end 
    511528 
    512     def response_doc_enc(result, mapping_registry) 
     529    def response_doc_enc(result, mapping_registry, opt) 
    513530      (0...result.size).collect { |idx| 
    514         ele = Mapping.obj2soap(result[idx], mapping_registry) 
     531        ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt) 
    515532        ele.elename = @doc_response_qnames[idx] 
    516533        ele 
    …… 
    518535    end 
    519536 
    520     def response_doc_lit(result, mapping_registry) 
     537    def response_doc_lit(result, mapping_registry, opt) 
    521538      (0...result.size).collect { |idx| 
    522         mapping_registry.obj2soap(result[idx], @doc_response_qnames[idx]) 
     539        ele = Mapping.obj2soap(result[idx], mapping_registry, 
     540          @doc_response_qnames[idx]) 
     541        ele.encodingstyle = LiteralNamespace 
     542        if ele.respond_to?(:qualified) 
     543          ele.qualified = @doc_response_qualified[idx] 
     544        end 
     545        ele 
    523546      } 
    524547    end 

  • trunk/lib/soap/rpc/soaplet.rb

    r1554 r1597  
    8585      conn_data = ::SOAP::StreamHandler::ConnectionData.new 
    8686      setup_req(conn_data, req) 
     87      @router.external_ces = @options[:external_ces] 
    8788      conn_data = @router.route(conn_data) 
    8889      setup_res(conn_data, req, res) 

  • trunk/test/interopR2/client.rb

    r1589 r1597  
    252252    var = drv.echoString(arg) 
    253253    assert_equal(arg, var) 
     254  end 
     255 
     256  def test_echoString_SJIS_encoded 
     257    log_test 
     258    arg = "Hello (����panese) ������ 
     259    require 'nkf' 
     260    arg = NKF.nkf("-sm0", arg) 
     261    drv.options["soap.mapping.external_ces"] = 'SJIS' 
     262    begin 
     263      var = drv.echoString(arg) 
     264      assert_equal(arg, var) 
     265    ensure 
     266      drv.options["soap.mapping.external_ces"] = nil 
     267    end 
    254268  end 
    255269 

  • trunk/test/interopR2/clientSOAP4R.rb

    r1592 r1597  
    55$server = 'http://dev.ctor.org/soapsrv' 
    66#$server = 'http://rrr.jin.gr.jp/soapsrv' 
     7#$server = 'http://dev.ctor.org/soapsrv' 
    78#$server = 'http://localhost:10080' 
    89#require 'xsd/datatypes1999' 
    …… 
    1516doTestBase(drv) 
    1617doTestGroupB(drv) 
    17 submitTestResult 
     18#submitTestResult 

  • trunk/test/soap/ssl/test_ssl.rb

    r1578 r1597  
    180180    cfg["protocol.http.ssl_config.ca_file"] = File.join(DIR, "subca.cert") 
    181181    #cfg.timeout = 123 
    182     assert_equal("Hello World, from ssl client", @client.hello_world("ssl client")) 
    183     # 
    184182    cfg["protocol.http.ssl_config.ciphers"] = "!ALL" 
     183    # 
    185184    begin 
    186185      @client.hello_world("ssl client")