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

Changeset 1411

Show
Ignore:
Timestamp:
02/02/05 18:40:38 (4 years ago)
Author:
nahi
Message:

merge WSDLDriver in wsdlDriver.rb and RPC::Driver in rpc/driver.rb.
added new factory interface 'WSDLDriverFactory#create_rpc_driver' to create RPC::Driver, not WSDLDriver. 'WSDLDriverFactory#create_driver' still creates WSDLDriver for compatibility but it warns that the method is deprecated. please use create_rpc_driver instead of create_driver. fixes #10.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1407 r1411  
    2121  attr_reader :definedtypes 
    2222  attr_accessor :excn_handler_obj2soap 
     23  attr_accessor :excn_handler_soap2obj 
    2324 
    2425  def initialize(definedtypes, config = {}) 
    …… 
    2627    @config = config 
    2728    @excn_handler_obj2soap = nil 
     29    @excn_handler_soap2obj = nil 
    2830    # For mapping AnyType element. 
    2931    @rubytype_factory = RubytypeFactory.new( 
    …… 
    5658  end 
    5759 
     60  # map anything for now: must refer WSDL while mapping.  [ToDo] 
    5861  def soap2obj(node) 
    59     raise RuntimeError.new("#{self} is for obj2soap only") 
     62    Mapping.soap2obj(node) 
    6063  end 
    6164 

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

    r1373 r1411  
    11# SOAP4R - WSDL literal mapping registry. 
    2 # Copyright (C) 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
     2# Copyright (C) 2004, 2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
    33 
    44# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can 
    …… 
    1111require 'soap/mapping/typeMap' 
    1212require 'xsd/codegen/gensupport' 
     13require 'xsd/namedelements' 
    1314 
    1415 
    …… 
    2324  attr_accessor :excn_handler_soap2obj 
    2425 
    25   def initialize(definedelements = nil, definedtypes = nil) 
     26  Empty = XSD::NamedElements.new.freeze 
     27 
     28  def initialize(definedelements = Empty, definedtypes = Empty) 
    2629    @definedelements = definedelements 
    2730    @definedtypes = definedtypes 
     31    @excn_handler_obj2soap = nil 
     32    @excn_handler_soap2obj = nil 
    2833    @rubytype_factory = RubytypeFactory.new(:allow_original_mapping => false) 
    2934    @schema_element_cache = {} 
    …… 
    3237  def obj2soap(obj, qname) 
    3338    ret = nil 
    34     if !@definedelements.nil? && ele = @definedelements[qname] 
     39    if ele = @definedelements[qname] 
    3540      ret = _obj2soap(obj, ele) 
    36     elsif !@definedtypes.nil? && type = @definedtypes[qname] 
     41    elsif type = @definedtypes[qname] 
    3742      ret = obj2type(obj, type) 
    3843    else 
    …… 
    4651      return ret if ret 
    4752    end 
    48     raise MappingError.new("Cannot map #{ obj.class.name } to SOAP/OM.") 
     53    raise MappingError.new("cannot map #{obj.class.name} to SOAP/OM") 
    4954  end 
    5055 
    …… 
    6368      end 
    6469    end 
    65     raise MappingError.new("Cannot map #{ node.type.name } to Ruby object.") 
     70    raise MappingError.new("cannot map #{node.type.name} to Ruby object") 
    6671  end 
    6772 
    …… 
    7681        o = base2soap(obj, type) 
    7782      else 
    78         raise MappingError.new("Cannot find type #{ele.type}.") 
     83        raise MappingError.new("cannot find type #{ele.type}") 
    7984      end 
    8085      o.elename = ele.name 
    …… 
    103108    if type.restriction.enumeration.empty? 
    104109      STDERR.puts( 
    105         "#{type.name}: simpleType which is not enum type not supported.") 
     110        "#{type.name}: simpleType which is not enum type not supported") 
    106111      return o 
    107112    end 

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

    r1406 r1411  
    102102  end 
    103103 
    104   def each_param_name(*type) 
    105     @signature.each do |io_type, name, param_type| 
    106       if type.include?(io_type) 
    107         yield(name) 
    108       end 
    109     end 
    110   end 
    111  
    112   def each_in_param_name 
    113     each_param_name(IN, INOUT) do |name| 
    114       yield name 
    115     end 
    116   end 
    117  
    118   def each_out_param_name 
    119     each_param_name(OUT, INOUT) do |name| 
    120       yield name 
    121     end 
     104  def input_params 
     105    collect_params(IN, INOUT) 
     106  end 
     107 
     108  def output_params 
     109    collect_params(OUT, INOUT) 
    122110  end 
    123111 
    …… 
    183171 
    184172private 
     173 
     174  def collect_params(*type) 
     175    names = [] 
     176    @signature.each do |io_type, name, param_type| 
     177      names << name if type.include?(io_type) 
     178    end 
     179    names 
     180  end 
    185181 
    186182  def init_param(param_def) 
    …… 
    235231 
    236232  def each 
    237     each_param_name(IN, INOUT) do |name| 
     233    input_params.each do |name| 
    238234      unless @inparam[name] 
    239235        raise ParameterError.new("parameter: #{name} was not given") 
    …… 
    285281    end 
    286282 
    287     each_param_name(OUT, INOUT) do |param_name| 
    288       unless @outparam[param_name] 
    289         raise ParameterError.new("parameter: #{param_name} was not given") 
    290       end 
    291       yield(param_name, @outparam[param_name]) 
     283    output_params.each do |name| 
     284      unless @outparam[name] 
     285        raise ParameterError.new("parameter: #{name} was not given") 
     286      end 
     287      yield(name, @outparam[name]) 
    292288    end 
    293289  end 

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

    r1406 r1411  
    8585    opt[:request_use] ||= :encoded 
    8686    opt[:response_use] ||= :encoded 
    87     @operation[name] = Operation.new(soapaction, name, param_def, opt) 
     87    @operation[name] = Operation.new(soapaction, param_def, opt) 
    8888  end 
    8989 
    …… 
    9393    opt[:request_use] ||= :literal 
    9494    opt[:response_use] ||= :literal 
    95     @operation[name] = Operation.new(soapaction, name, param_def, opt) 
     95    @operation[name] = Operation.new(soapaction, param_def, opt) 
    9696  end 
    9797 
    …… 
    130130  end 
    131131 
    132   def check_fault(body) 
    133     if body.fault 
    134       raise SOAP::FaultError.new(body.fault) 
    135     end 
    136   end 
    137  
    138 private 
    139  
    140132  def route(req_header, req_body, reqopt, resopt) 
    141133    req_env = SOAPEnvelope.new(req_header, req_body) 
    …… 
    159151    unmarshal(conn_data, resopt) 
    160152  end 
     153 
     154  def check_fault(body) 
     155    if body.fault 
     156      raise SOAP::FaultError.new(body.fault) 
     157    end 
     158  end 
     159 
     160private 
    161161 
    162162  def create_request_header 
    …… 
    229229    attr_reader :response_use 
    230230 
    231     def initialize(soapaction, name, param_def, opt) 
     231    def initialize(soapaction, param_def, opt) 
    232232      @soapaction = soapaction 
    233       @name = name 
    234233      @request_style = opt[:request_style] 
    235234      @response_style = opt[:response_style] 
    …… 
    241240      check_use(@response_use) 
    242241      if @request_style == :rpc 
    243         request_qname = opt[:request_qname] or raise 
     242        @rpc_request_qname = opt[:request_qname] 
     243        if @rpc_request_qname.nil? 
     244          raise MethodDefinitionError.new("rpc_request_qname must be given") 
     245        end 
    244246        @rpc_method_factory = 
    245           RPC::SOAPMethodRequest.new(request_qname, param_def, @soapaction) 
     247          RPC::SOAPMethodRequest.new(@rpc_request_qname, param_def, @soapaction) 
    246248      else 
    247249        @doc_request_qnames = [] 
    …… 
    321323    def request_rpc_enc(values, mapping_registry) 
    322324      method = @rpc_method_factory.dup 
    323       values = Mapping.obj2soap(values, mapping_registry).to_a 
    324       params = {} 
    325       idx = 0 
    326       method.each_in_param_name do |name| 
    327         params[name] = values[idx] || SOAPNil.new 
    328         idx += 1 
    329       end 
    330       method.set_param(params) 
     325      names = method.input_params 
     326      obj = create_request_obj(names, values) 
     327      soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname) 
     328      method.set_param(soap) 
    331329      method 
    332330    end 
    …… 
    336334      params = {} 
    337335      idx = 0 
    338       method.each_in_param_name do |name| 
     336      method.input_params.each do |name| 
    339337        params[name] = SOAPElement.from_obj(values[idx]) 
    340338        idx += 1 
    …… 
    353351      (0...values.size).collect { |idx| 
    354352        item = values[idx] 
    355         unless item.respond_to?(:size) and item.size == 1 
    356           raise ArgumentError.new( 
    357           "values element is expected to be Hash-like object with one key") 
    358         end 
    359353        qname = @doc_request_qnames[idx] 
    360354        ele = SOAPElement.from_obj(item, qname.namespace) 
    …… 
    374368    def response_doc(body, mapping_registry) 
    375369      if @response_use == :encoded 
    376         response_doc_enc(body, mapping_registry) 
    377       else 
    378         response_doc_lit(body, mapping_registry) 
     370        return *response_doc_enc(body, mapping_registry) 
     371      else 
     372        return *response_doc_lit(body, mapping_registry) 
    379373      end 
    380374    end 
    …… 
    397391    def response_rpc_lit(body, mapping_registry) 
    398392      body.root_node.collect { |key, value| 
    399         value.to_obj 
     393        value.respond_to?(:to_obj) ? value.to_obj : value.data 
    400394      } 
    401395    end 
    …… 
    409403    def response_doc_lit(body, mapping_registry) 
    410404      body.collect { |key, value| 
    411         value.to_obj 
     405        value.respond_to?(:to_obj) ? value.to_obj : value.data 
    412406      } 
     407    end 
     408 
     409    def create_request_obj(names, params) 
     410      o = Object.new 
     411      for idx in 0 ... params.length 
     412        o.instance_variable_set('@' + names[idx], params[idx]) 
     413      end 
     414      o 
    413415    end 
    414416  end 

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

    r1406 r1411  
    393393    def request_rpc_lit(request) 
    394394      request.collect { |key, value| 
    395         value.to_obj 
     395        value.respond_to?(:to_obj) ? value.to_obj : value.data 
    396396      } 
    397397    end 
    …… 
    405405    def request_doc_lit(body) 
    406406      body.collect { |key, value| 
    407         value.to_obj 
     407        value.respond_to?(:to_obj) ? value.to_obj : value.data 
    408408      } 
    409409    end 
    …… 
    441441        outparams = {} 
    442442        i = 1 
    443         soap_response.each_out_param_name do |outparam| 
     443        soap_response.output_params.each do |outparam| 
    444444          outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry) 
    445445          i += 1 
    …… 
    462462        outparams = {} 
    463463        i = 1 
    464         soap_response.each_out_param_name do |outparam| 
     464        soap_response.output_params.each do |outparam| 
    465465          outparams[outparam] = SOAPElement.from_obj(result[i]) 
    466466          i += 1 
    …… 
    485485      (0...result.size).collect { |idx| 
    486486        item = result[idx] 
    487         unless item.respond_to?(:size) and item.size == 1 
    488           raise ArgumentError.new( 
    489             "result element is expected to be Hash-like object with one key") 
    490         end 
    491487        qname = @doc_response_qnames[idx] 
    492488        ele = SOAPElement.from_obj(item, qname.namespace) 

  • trunk/lib/soap/wsdlDriver.rb

    r1397 r1411  
    1010require 'wsdl/importer' 
    1111require 'xsd/qname' 
    12 require 'soap/element' 
    13 require 'soap/baseData' 
    14 require 'soap/streamHandler' 
    15 require 'soap/mimemessage' 
    16 require 'soap/mapping' 
     12require 'xsd/codegen/gensupport' 
    1713require 'soap/mapping/wsdlencodedregistry' 
    1814require 'soap/mapping/wsdlliteralregistry' 
    19 require 'soap/rpc/rpc' 
    20 require 'soap/rpc/element' 
    21 require 'soap/rpc/proxy' 
    22 require 'soap/processor' 
    23 require 'soap/header/handlerset' 
    24 require 'xsd/codegen/gensupport' 
     15require 'soap/rpc/driver' 
    2516 
    2617 
    …… 
    3324  attr_reader :wsdl 
    3425 
    35   def initialize(wsdl, logdev = nil) 
    36     @logdev = logdev 
     26  def initialize(wsdl) 
    3727    @wsdl = import(wsdl) 
    3828  end 
    …… 
    4232  end 
    4333 
     34  def create_rpc_driver(servicename = nil, portname = nil) 
     35    port = find_port(servicename, portname) 
     36    drv = SOAP::RPC::Driver.new(port.soap_address.location) 
     37    init_driver(drv, port) 
     38    add_operation(drv, port) 
     39    drv 
     40  end 
     41 
     42  # depricated old interface 
    4443  def create_driver(servicename = nil, portname = nil) 
    45     service = if servicename 
    46         @wsdl.service(XSD::QName.new(@wsdl.targetnamespace, servicename)) 
    47       else 
    48         @wsdl.services[0] 
    49       end 
     44    STDERR.puts "WSDLDriverFactory#create_driver is depricated." + 
     45      "  Use create_rpc_driver instead." 
     46    port = find_port(servicename, portname) 
     47    WSDLDriver.new(@wsdl, port, @logdev) 
     48  end 
     49 
     50  # Backward compatibility. 
     51  alias createDriver create_driver 
     52 
     53private 
     54 
     55  def find_port(servicename = nil, portname = nil) 
     56    service = port = nil 
     57    if servicename 
     58      service = @wsdl.service( 
     59        XSD::QName.new(@wsdl.targetnamespace, servicename)) 
     60    else 
     61      service = @wsdl.services[0] 
     62    end 
    5063    if service.nil? 
    51       raise FactoryError.new("service #{ servicename } not found in WSDL") 
    52     end 
    53     port = if portname 
    54        service.ports[XSD::QName.new(@wsdl.targetnamespace, portname)] 
    55       else 
    56        service.ports[0] 
    57       end 
     64      raise FactoryError.new("service #{servicename} not found in WSDL") 
     65    end 
     66    if portname 
     67      port = service.ports[XSD::QName.new(@wsdl.targetnamespace, portname)] 
     68    else 
     69      port = service.ports[0] 
     70    end 
    5871    if port.nil? 
    59       raise FactoryError.new("port #{ portname } not found in WSDL") 
     72      raise FactoryError.new("port #{portname} not found in WSDL") 
    6073    end 
    6174    if port.soap_address.nil? 
    6275      raise FactoryError.new("soap:address element not found in WSDL") 
    6376    end 
    64     WSDLDriver.new(@wsdl, port, @logdev) 
    65   end 
    66  
    67   # Backward compatibility. 
    68   alias createDriver create_driver 
    69  
    70 private 
    71    
     77    port 
     78  end 
     79 
     80  def init_driver(drv, port) 
     81    wsdl_elements = @wsdl.collect_elements 
     82    wsdl_types = @wsdl.collect_complextypes + @wsdl.collect_simpletypes 
     83    rpc_decode_typemap = wsdl_types + 
     84      @wsdl.soap_rpc_complextypes(port.find_binding) 
     85    drv.proxy.mapping_registry = 
     86      Mapping::WSDLEncodedRegistry.new(rpc_decode_typemap) 
     87    drv.proxy.literal_mapping_registry = 
     88      Mapping::WSDLLiteralRegistry.new(wsdl_elements, wsdl_types) 
     89  end 
     90 
     91  def add_operation(drv, port) 
     92    # Convert a map which key is QName, to a Hash which key is String. 
     93    port.find_binding.operations.each do |op_bind| 
     94      op = op_bind.find_operation 
     95 
     96      soapaction = op_bind.soapoperation.soapaction 
     97      orgname = op.name.name 
     98      name = ::XSD::CodeGen::GenSupport.safemethodname(orgname) 
     99      param_def = create_param_def(op_bind) 
     100      opt = {} 
     101      opt[:request_style] = opt[:response_style] = 
     102        op_bind.soapoperation.operation_style || :document 
     103      opt[:request_use] = (op_bind.input.soapbody.use || 'literal').intern 
     104      opt[:response_use] = (op_bind.output.soapbody.use || 'literal').intern 
     105      if op_bind.soapoperation.operation_style == :rpc 
     106        qname = op.inputname 
     107        drv.add_rpc_operation(qname, soapaction, name, param_def, opt) 
     108      else 
     109        drv.add_document_operation(soapaction, name, param_def, opt) 
     110      end 
     111      if orgname != name and orgname.capitalize == name.capitalize 
     112        sclass = class << drv; self; end 
     113        sclass.__send__(:define_method, orgname, proc { |*arg| 
     114          __send__(name, *arg) 
     115        }) 
     116      end 
     117    end 
     118  end 
     119 
    72120  def import(location) 
    73121    WSDL::Importer.import(location) 
     122  end 
     123 
     124  def create_param_def(op_bind) 
     125    op = op_bind.find_operation 
     126    param_def = [] 
     127    inputparts = op.inputparts 
     128    if op_bind.input.soapbody.parts 
     129      inputparts = filter_parts(op_bind.input.soapbody.parts, inputparts) 
     130    end 
     131    inputparts.each do |part| 
     132      partqname = partqname(part) 
     133      param_def << param_def(::SOAP::RPC::SOAPMethod::IN, partqname) 
     134    end 
     135    outputparts = op.outputparts 
     136    if op_bind.output.soapbody.parts 
     137      outputparts = filter_parts(op_bind.output.soapbody.parts, outputparts) 
     138    end 
     139    if op_bind.soapoperation.operation_style == :rpc 
     140      part = outputparts.shift 
     141      param_def << param_def(::SOAP::RPC::SOAPMethod::RETVAL, partqname(part)) 
     142      outputparts.each do |part| 
     143        param_def << param_def(::SOAP::RPC::SOAPMethod::OUT, partqname(part)) 
     144      end 
     145    else 
     146      outputparts.each do |part| 
     147        param_def << param_def(::SOAP::RPC::SOAPMethod::OUT, partqname(part)) 
     148      end 
     149    end 
     150    param_def 
     151  end 
     152 
     153  def partqname(part) 
     154    if part.type 
     155      XSD::QName.new(@wsdl.targetnamespace, part.name) 
     156    else 
     157      part.element 
     158    end 
     159  end 
     160 
     161  def param_def(type, partqname) 
     162    [type, partqname.name, [nil, partqname.namespace, partqname.name]] 
     163  end 
     164 
     165  def filter_parts(partsdef, partssource) 
     166    parts = partsdef.split(/\s+/) 
     167    partssource.find_all { |part| parts.include?(part.name) } 
    74168  end 
    75169end 
    …… 
    227321      req_header = create_request_header 
    228322      req_body = create_request_body(op_info, *values) 
    229       opt = create_options({ 
    230         :soapaction => op_info.soapaction || @soapaction, 
     323      reqopt = create_options({ 
     324        :soapaction => op_info.soapaction || @soapaction}) 
     325      resopt = create_options({ 
    231326        :decode_typemap => @rpc_decode_typemap}) 
    232       env = @proxy.invoke(req_header, req_body, opt) 
     327      env = @proxy.route(req_header, req_body, reqopt, resopt) 
     328      receive_headers(env.header) 
    233329      raise EmptyResponseError.new("empty response") unless env 
    234       receive_headers(env.header) 
    235330      begin 
    236331        @proxy.check_fault(env.body) 
    …… 
    250345    end 
    251346 
    252     def document_call(name, param) 
     347    def document_call(name, *values) 
    253348      set_wiredump_file_base(name) 
    254       op_info = @operation[name] 
    255       req_header = header_from_obj(header_obj, op_info) 
     349      unless op_info = @operation[name] 
     350        raise RuntimeError, "method: #{name} not defined" 
     351      end 
     352      req_header = create_request_header 
     353 
     354 
    256355      req_body = body_from_obj(body_obj, op_info) 
    257356      env = @proxy.invoke(req_header, req_body, op_info.soapaction || @soapaction, @wsdl_types) 
    …… 
    298397    def set_wiredump_file_base(name) 
    299398      if @wiredump_file_base 
    300         @proxy.set_wiredump_file_base(@wiredump_file_base + "_#{ name }") 
     399        @proxy.set_wiredump_file_base(@wiredump_file_base + "_#{name}") 
    301400      end 
    302401    end 
    …… 
    421520    def add_method_interface(op_info) 
    422521      name = ::XSD::CodeGen::GenSupport.safemethodname(op_info.op_name.name) 
     522      orgname = op_info.op_name.name 
     523      parts_names = op_info.bodyparts.collect { |part| part.name } 
    423524      case op_info.style 
    424525      when :document 
    425         add_document_method_interface(name) 
     526        if orgname != name and orgname.capitalize == name.capitalize 
     527          add_document_method_interface(orgname, parts_names) 
     528        end 
     529        add_document_method_interface(name, parts_names) 
    426530      when :rpc 
    427         parts_names = op_info.bodyparts.collect { |part| part.name } 
    428         orgname = op_info.op_name.name 
    429531        if orgname != name and orgname.capitalize == name.capitalize 
    430532          add_rpc_method_interface(orgname, parts_names) 
    …… 
    432534        add_rpc_method_interface(name, parts_names) 
    433535      else 
    434         raise RuntimeError.new("Unknown style: #{op_info.style}") 
     536        raise RuntimeError.new("unknown style: #{op_info.style}") 
    435537      end 
    436538    end 
    …… 
    448550    end 
    449551 
    450     def add_document_method_interface(name) 
     552    def add_document_method_interface(name, parts_names) 
    451553      sclass = class << @host; self; end 
    452       sclass.__send__(:define_method, name, proc { |h, b| 
    453         @servant.document_send(name, h, b) 
     554      sclass.__send__(:define_method, name, proc { |*arg| 
     555        unless arg.size == parts_names.size 
     556          raise ArgumentError.new( 
     557            "wrong number of arguments (#{arg.size} for #{parts_names.size})") 
     558        end 
     559        @servant.document_call(name, *arg) 
    454560      }) 
    455561      @host.method(name) 
    …… 
    477583 
    478584end 
    479  
    480  

  • trunk/lib/wsdl/operation.rb

    r1369 r1411  
    4747 
    4848  def input_info 
    49     op_name = @name 
    50     optype_name = XSD::QName.new(targetnamespace, input.name ? input.name.name : @name.name) 
    51     NameInfo.new(op_name, optype_name, inputparts) 
     49    NameInfo.new(@name, inputname, inputparts) 
    5250  end 
    5351 
    5452  def output_info 
    55     op_name = @name 
    56     optype_name = XSD::QName.new(targetnamespace, output.name ? output.name.name : @name.name) 
    57     NameInfo.new(op_name, optype_name, outputparts) 
     53    NameInfo.new(@name, outputname, outputparts) 
    5854  end 
    5955 
    …… 
    6258  end 
    6359 
     60  def inputname 
     61    XSD::QName.new(targetnamespace, input.name ? input.name.name : @name.name) 
     62  end 
     63 
    6464  def outputparts 
    6565    sort_parts(output.find_message.parts) 
     66  end 
     67 
     68  def outputname 
     69    XSD::QName.new(targetnamespace, 
     70      output.name ? output.name.name : @name.name + "Response") 
    6671  end 
    6772 

  • trunk/lib/wsdl/soap/definitions.rb

    r1238 r1411  
    112112        operation = op_bind.find_operation 
    113113        if op_bind.input 
    114           type = XMLSchema::ComplexType.new(operation_input_name(operation)) 
     114          type = XMLSchema::ComplexType.new(operation.inputname) 
    115115          message = messages[operation.input.message] 
    116116          type.sequence_elements = elements_from_message(message) 
    …… 
    118118        end 
    119119        if op_bind.output 
    120           type = XMLSchema::ComplexType.new(operation_output_name(operation)) 
     120          type = XMLSchema::ComplexType.new(operation.outputname) 
    121121          message = messages[operation.output.message] 
    122122          type.sequence_elements = elements_from_message(message) 
    …… 
    126126    end 
    127127    types 
    128   end 
    129  
    130   def operation_input_name(operation) 
    131     operation.input.name || operation.name 
    132   end 
    133  
    134   def operation_output_name(operation) 
    135     operation.output.name || 
    136       XSD::QName.new(operation.name.namespace, operation.name.name + "Response") 
    137128  end 
    138129 

  • trunk/lib/xsd/namedelements.rb

    r1285 r1411  
    11# XSD4R - WSDL named element collection. 
    2 # Copyright (C) 2002, 2003  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
     2# Copyright (C) 2002, 2003, 2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
    33 
    44# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can 
    …… 
    2222    o.elements = @elements.dup 
    2323    o 
     24  end 
     25 
     26  def freeze 
     27    super 
     28    @elements.freeze 
     29    self 
    2430  end 
    2531 

  • trunk/test/wsdl/datetime/DatetimeService.rb

    r1395 r1411  
    1010 
    1111  Methods = [ 
    12     ["now", "now", [ 
     12    ["nowRequest", "now", [ 
    1313      ["in", "now", 
    1414       [SOAP::SOAPDateTime]], 

  • trunk/test/wsdl/datetime/test_datetime.rb

    r1178 r1411  
    3939    @client.endpoint_url = "http://localhost:#{Port}/" 
    4040    @client.generate_explicit_type = true 
     41    @client.wiredump_dev = STDOUT if $DEBUG 
    4142  end 
    4243 

  • trunk/test/wsdl/simpletype/test_simpletype.rb

    r1187 r1411  
    1111  class Server < ::SOAP::RPC::StandaloneServer 
    1212    def on_init 
    13       add_method(self, 'ruby', 'version', 'date') 
     13      add_document_method(self, 'urn:example.com:simpletype', 'ruby', 
     14        XSD::QName.new('urn:example.com:simpletype', 'ruby'), 
     15        XSD::QName.new('http://www.w3.org/2001/XMLSchema', 'string')) 
    1416    end 
    1517   
    16     def ruby(version, date) 
     18    def ruby(ruby) 
     19      version = ruby["version"] 
     20      date = ruby["date"] 
    1721      "#{version} (#{date})" 
    1822    end 
    …… 
    3943    @client.endpoint_url = "http://localhost:#{Port}/" 
    4044    @client.generate_explicit_type = false 
     45    @client.wiredump_dev = STDOUT if $DEBUG 
    4146  end 
    4247 
    …… 
    7277 
    7378  def test_ping 
    74     header, body = @client.ping(nil, {:version => "1.9", :date => "2004-01-01T00:00:00Z"}) 
    75     assert_equal("1.9 (2004-01-01T00:00:00Z)", body) 
     79    ret = @client.ping({:version => "1.9", :date => "2004-01-01T00:00:00Z"}) 
     80    assert_equal("1.9 (2004-01-01T00:00:00Z)", ret) 
    7681  end 
    7782end 

  • trunk/test/wsdl/soap/test_soapbodyparts.rb

    r1159 r1411  
    7575 
    7676  def test_soapbodyparts 
    77     assert_equal(["2", "1"], @client.foo("1", "2")) 
    78     assert_equal(["1", "2"], @client.foo("2", "1")) 
     77    assert_equal(["1", "2"], @client.foo("1", "2")) 
     78    assert_equal(["2", "1"], @client.foo("2", "1")) 
    7979    assert_equal(["2", "3"], @client.bar("2", "3")) 
    8080    assert_equal(["1", "2", "3"], @client.baz("1", "2", "3"))