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

Changeset 1574

Show
Ignore:
Timestamp:
07/14/05 21:46:02 (3 years ago)
Author:
nahi
Message:

rpc/literal did not work with wsdl2ruby.rb. changes for #118. not completed.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/wsdlDriver.rb

    r1566 r1574  
    102102      opt = {} 
    103103      opt[:request_style] = opt[:response_style] = op_bind.soapoperation_style 
    104       opt[:request_use] = (op_bind.input.soapbody.use || 'literal').intern 
    105       opt[:response_use] = (op_bind.output.soapbody.use || 'literal').intern 
     104      opt[:request_use] = op_bind.input.soapbody_use 
     105      opt[:response_use] = op_bind.output.soapbody_use 
    106106      if op_bind.soapoperation_style == :rpc 
    107107        drv.add_rpc_operation(op_name, soapaction, name, param_def, opt) 

  • trunk/lib/wsdl/param.rb

    r1520 r1574  
    3535  def find_message 
    3636    root.message(@message) or raise RuntimeError.new("#{@message} not found") 
     37  end 
     38 
     39  def soapbody_use 
     40    if @soapbody 
     41      @soapbody.use || :literal 
     42    else 
     43      raise RuntimeError.new("soap:body not found") 
     44    end 
    3745  end 
    3846 

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

    r1520 r1574  
    3737      @parts = value.source 
    3838    when UseAttrName 
    39       @use = value.source 
     39      if ['literal', 'encoded'].include?(value.source) 
     40        @use = value.source.intern 
     41      else 
     42        raise RuntimeError.new("unknown use of soap:body: #{value.source}") 
     43      end 
    4044    when EncodingStyleAttrName 
    4145      @encodingstyle = value.source 

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

    r1552 r1574  
    5454        super(*arg) 
    5555        servant = #{class_name}.new 
    56         #{class_name}::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    57           if style == :document 
    58             @router.add_document_operation(servant, soapaction, name, param_def) 
     56        #{class_name}::Methods.each do |definitions| 
     57          opt = definitions.last 
     58          if opt[:request_style] == :document 
     59            @router.add_document_operation(servant, *definitions) 
    5960          else 
    60             qname = XSD::QName.new(namespace, name_as) 
    61             @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     61            @router.add_rpc_operation(servant, *definitions) 
    6262          end 
    6363        end 

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

    r1520 r1574  
    4343obj = #{ drv_name }.new(endpoint_url) 
    4444 
    45 # Uncomment the below line to see SOAP wiredumps. 
    46 # obj.wiredump_dev = STDERR 
     45# run ruby with -d to see SOAP wiredumps. 
     46obj.wiredump_dev = STDERR if $DEBUG 
    4747 
    4848__EOD__ 

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

    r1533 r1574  
    7070    c.def_privatemethod("init_methods") do 
    7171      <<-EOD 
    72         Methods.each do |name_as, name, params, soapaction, namespace, style| 
    73           qname = XSD::QName.new(namespace, name_as) 
    74           if style == :document 
    75             @proxy.add_document_method(soapaction, name, params) 
    76             add_document_method_interface(name, params) 
     72        Methods.each do |definitions| 
     73          opt = definitions.last 
     74          if opt[:request_style] == :document 
     75            add_document_operation(*definitions) 
    7776          else 
    78             @proxy.add_rpc_method(qname, soapaction, name, params) 
    79             add_rpc_method_interface(name, params) 
    80           end 
    81           if name_as != name and name_as.capitalize == name.capitalize 
    82             ::SOAP::Mapping.define_singleton_method(self, name_as) do |*arg| 
    83               __send__(name, *arg) 
     77            add_rpc_operation(*definitions) 
     78            qname = definitions[0] 
     79            name = definitions[2] 
     80            if qname.name != name and qname.name.capitalize == name.capitalize 
     81              ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg| 
     82                __send__(name, *arg) 
     83              end 
    8484            end 
    8585          end 

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

    r1538 r1574  
    8383    name_as = operation.name.name 
    8484    style = binding.soapoperation_style 
     85    inputuse = binding.input.soapbody_use 
     86    outputuse = binding.output.soapbody_use 
    8587    namespace = binding.input.soapbody.namespace 
    8688    if style == :rpc 
     89      qname = XSD::QName.new(namespace, name_as) 
    8790      paramstr = param2str(collect_rpcparameter(operation)) 
    8891    else 
     92      qname = nil 
    8993      paramstr = param2str(collect_documentparameter(operation)) 
    9094    end 
    …… 
    9296      paramstr = '[]' 
    9397    else 
    94       paramstr = "[\n" << paramstr.gsub(/^/, '    ') << "\n  ]" 
    95     end 
    96     return <<__EOD__ 
    97 [#{dq(name_as)}, #{dq(name)}, 
     98      paramstr = "[ " << paramstr.split(/\r?\n/).join("\n    ") << " ]" 
     99    end 
     100    definitions = <<__EOD__ 
     101#{ndq(binding.soapaction)}, 
     102  #{dq(name)}, 
    98103  #{paramstr}, 
    99   #{ndq(binding.soapaction)}, #{ndq(namespace)}, #{sym(style.id2name)} 
    100 ] 
     104  { :request_style =>  #{sym(style.id2name)}, :request_use =>  #{sym(inputuse.id2name)}, 
     105    :response_style => #{sym(style.id2name)}, :response_use => #{sym(outputuse.id2name)} } 
    101106__EOD__ 
     107    if style == :rpc 
     108      return <<__EOD__ 
     109[ #{qname.dump}, 
     110  #{definitions}] 
     111__EOD__ 
     112    else 
     113      return <<__EOD__ 
     114[ #{definitions}] 
     115__EOD__ 
     116    end 
    102117  end 
    103118 

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

    r1552 r1574  
    5656        super(*arg) 
    5757        servant = #{class_name}.new 
    58         #{class_name}::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    59           if style == :document 
    60             @router.add_document_operation(servant, soapaction, name, param_def) 
     58        #{class_name}::Methods.each do |definitions| 
     59          opt = definitions.last 
     60          if opt[:request_style] == :document 
     61            @router.add_document_operation(servant, *definitions) 
    6162          else 
    62             qname = XSD::QName.new(namespace, name_as) 
    63             @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     63            @router.add_rpc_operation(servant, *definitions) 
    6464          end 
    6565        end 

  • trunk/lib/wsdl/xmlSchema/importer.rb

    r1552 r1574  
    5454      client.no_proxy = ::SOAP::Env::NO_PROXY 
    5555      if opt = ::SOAP::Property.loadproperty(::SOAP::PropertyName) 
    56         ::SOAP::HTTPConfigLoader.set_options(client, opt["client.protocol.http"]) 
     56        ::SOAP::HTTPConfigLoader.set_options(client, 
     57          opt["client.protocol.http"]) 
    5758      end 
    5859      content = client.get_content(location) 

  • trunk/sample/soap/ssl/sslclient_with_clientauth.rb

    r1520 r1574  
    33 
    44# setup driver 
    5 url = "https://localhost:17443/" 
     5url = ARGV.shift || "https://localhost:17443/" 
    66client = SOAP::RPC::Driver.new(url, 'urn:sslhelloworld') 
    77client.add_method("hello_world", "from") 

  • trunk/test/wsdl/any/expectedDriver.rb

    r1532 r1574  
    1515 
    1616  Methods = [ 
    17     ["echo", "echo", 
    18       [ 
    19         ["in", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]], 
    20         ["retval", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]] 
    21       ], 
    22       "urn:example.com:echo", "urn:example.com:echo", :rpc 
     17    [ XSD::QName.new("urn:example.com:echo", "echo"), 
     18      "urn:example.com:echo", 
     19      "echo", 
     20      [ ["in", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]], 
     21        ["retval", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]] ], 
     22      { :request_style =>  :rpc, :request_use =>  :encoded, 
     23        :response_style => :rpc, :response_use => :encoded } 
    2324    ] 
    2425  ] 
    …… 
    3435 
    3536  def init_methods 
    36     Methods.each do |name_as, name, params, soapaction, namespace, style| 
    37       qname = XSD::QName.new(namespace, name_as) 
    38       if style == :document 
    39         @proxy.add_document_method(soapaction, name, params) 
    40         add_document_method_interface(name, params) 
     37    Methods.each do |definitions| 
     38      opt = definitions.last 
     39      if opt[:request_style] == :document 
     40        add_document_operation(*definitions) 
    4141      else 
    42         @proxy.add_rpc_method(qname, soapaction, name, params) 
    43         add_rpc_method_interface(name, params) 
    44       end 
    45       if name_as != name and name_as.capitalize == name.capitalize 
    46         ::SOAP::Mapping.define_singleton_method(self, name_as) do |*arg| 
    47           __send__(name, *arg) 
     42        add_rpc_operation(*definitions) 
     43        qname = definitions[0] 
     44        name = definitions[2] 
     45        if qname.name != name and qname.name.capitalize == name.capitalize 
     46          ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg| 
     47            __send__(name, *arg) 
     48          end 
    4849        end 
    4950      end 

  • trunk/test/wsdl/any/expectedService.rb

    r1532 r1574  
    1616 
    1717  Methods = [ 
    18     ["echo", "echo", 
    19       [ 
    20         ["in", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]], 
    21         ["retval", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]] 
    22       ], 
    23       "urn:example.com:echo", "urn:example.com:echo", :rpc 
     18    [ XSD::QName.new("urn:example.com:echo", "echo"), 
     19      "urn:example.com:echo", 
     20      "echo", 
     21      [ ["in", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]], 
     22        ["retval", "echoitem", ["FooBar", "urn:example.com:echo-type", "foo.bar"]] ], 
     23      { :request_style =>  :rpc, :request_use =>  :encoded, 
     24        :response_style => :rpc, :response_use => :encoded } 
    2425    ] 
    2526  ] 
    …… 
    3031    super(*arg) 
    3132    servant = Echo_port_type.new 
    32     Echo_port_type::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    33       if style == :document 
    34         @router.add_document_operation(servant, soapaction, name, param_def) 
     33    Echo_port_type::Methods.each do |definitions| 
     34      opt = definitions.last 
     35      if opt[:request_style] == :document 
     36        @router.add_document_operation(servant, *definitions) 
    3537      else 
    36         qname = XSD::QName.new(namespace, name_as) 
    37         @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     38        @router.add_rpc_operation(servant, *definitions) 
    3839      end 
    3940    end 

  • trunk/test/wsdl/rpc/test_rpc_lit.rb

    r1569 r1574  
    4949    teardown_server 
    5050    File.unlink(pathname('RPC-Literal-TestDefinitions.rb')) 
     51    File.unlink(pathname('RPC-Literal-TestDefinitionsDriver.rb')) 
    5152    @client.reset_stream if @client 
    5253  end 
    …… 
    6465    gen.logger.level = Logger::FATAL 
    6566    gen.opt['classdef'] = nil 
     67    gen.opt['driver'] = nil 
    6668    gen.opt['force'] = true 
    6769    gen.run 
    6870    require pathname('RPC-Literal-TestDefinitions.rb') 
     71    require pathname('RPC-Literal-TestDefinitionsDriver.rb') 
    6972  end 
    7073 
    …… 
    9497    assert_equal(["a", "b", "c"], @client.echoStringArray(["a", "b", "c"]).item) 
    9598  end 
     99 
     100  def test_stub 
     101    drv = SoapTestPortTypeRpc.new("http://localhost:#{Port}/") 
     102    drv.wiredump_dev = STDOUT if $DEBUG 
     103    assert_equal(["a", "b", "c"], drv.echoStringArray(["a", "b", "c"])) 
     104  end 
    96105end 
    97106 

  • trunk/test/wsdl/simpletype/rpc/expectedClient.rb

    r1520 r1574  
    55obj = Echo_version_port_type.new(endpoint_url) 
    66 
    7 # Uncomment the below line to see SOAP wiredumps. 
    8 # obj.wiredump_dev = STDERR 
     7# run ruby with -d to see SOAP wiredumps. 
     8obj.wiredump_dev = STDERR if $DEBUG 
    99 
    1010# SYNOPSIS 

  • trunk/test/wsdl/simpletype/rpc/expectedDriver.rb

    r1532 r1574  
    1515 
    1616  Methods = [ 
    17     ["echo_version", "echo_version", 
    18       [ 
    19         ["in", "version", ["::SOAP::SOAPString"]], 
    20         ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] 
    21       ], 
    22       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     17    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version"), 
     18      "urn:example.com:simpletype-rpc", 
     19      "echo_version", 
     20      [ ["in", "version", ["::SOAP::SOAPString"]], 
     21        ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] ], 
     22      { :request_style =>  :rpc, :request_use =>  :encoded, 
     23        :response_style => :rpc, :response_use => :encoded } 
    2324    ], 
    24     ["echo_version_r", "echo_version_r", 
    25       [ 
    26         ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
    27         ["retval", "version", ["::SOAP::SOAPString"]] 
    28       ], 
    29       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     25    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version_r"), 
     26      "urn:example.com:simpletype-rpc", 
     27      "echo_version_r", 
     28      [ ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
     29        ["retval", "version", ["::SOAP::SOAPString"]] ], 
     30      { :request_style =>  :rpc, :request_use =>  :encoded, 
     31        :response_style => :rpc, :response_use => :encoded } 
    3032    ] 
    3133  ] 
    …… 
    4143 
    4244  def init_methods 
    43     Methods.each do |name_as, name, params, soapaction, namespace, style| 
    44       qname = XSD::QName.new(namespace, name_as) 
    45       if style == :document 
    46         @proxy.add_document_method(soapaction, name, params) 
    47         add_document_method_interface(name, params) 
     45    Methods.each do |definitions| 
     46      opt = definitions.last 
     47      if opt[:request_style] == :document 
     48        add_document_operation(*definitions) 
    4849      else 
    49         @proxy.add_rpc_method(qname, soapaction, name, params) 
    50         add_rpc_method_interface(name, params) 
    51       end 
    52       if name_as != name and name_as.capitalize == name.capitalize 
    53         ::SOAP::Mapping.define_singleton_method(self, name_as) do |*arg| 
    54           __send__(name, *arg) 
     50        add_rpc_operation(*definitions) 
     51        qname = definitions[0] 
     52        name = definitions[2] 
     53        if qname.name != name and qname.name.capitalize == name.capitalize 
     54          ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg| 
     55            __send__(name, *arg) 
     56          end 
    5557        end 
    5658      end 

  • trunk/test/wsdl/simpletype/rpc/expectedService.rb

    r1532 r1574  
    1616 
    1717  Methods = [ 
    18     ["echo_version", "echo_version", 
    19       [ 
    20         ["in", "version", ["::SOAP::SOAPString"]], 
    21         ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] 
    22       ], 
    23       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     18    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version"), 
     19      "urn:example.com:simpletype-rpc", 
     20      "echo_version", 
     21      [ ["in", "version", ["::SOAP::SOAPString"]], 
     22        ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] ], 
     23      { :request_style =>  :rpc, :request_use =>  :encoded, 
     24        :response_style => :rpc, :response_use => :encoded } 
    2425    ], 
    25     ["echo_version_r", "echo_version_r", 
    26       [ 
    27         ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
    28         ["retval", "version", ["::SOAP::SOAPString"]] 
    29       ], 
    30       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     26    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version_r"), 
     27      "urn:example.com:simpletype-rpc", 
     28      "echo_version_r", 
     29      [ ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
     30        ["retval", "version", ["::SOAP::SOAPString"]] ], 
     31      { :request_style =>  :rpc, :request_use =>  :encoded, 
     32        :response_style => :rpc, :response_use => :encoded } 
    3133    ] 
    3234  ] 
    …… 
    3739    super(*arg) 
    3840    servant = Echo_version_port_type.new 
    39     Echo_version_port_type::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    40       if style == :document 
    41         @router.add_document_operation(servant, soapaction, name, param_def) 
     41    Echo_version_port_type::Methods.each do |definitions| 
     42      opt = definitions.last 
     43      if opt[:request_style] == :document 
     44        @router.add_document_operation(servant, *definitions) 
    4245      else 
    43         qname = XSD::QName.new(namespace, name_as) 
    44         @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     46        @router.add_rpc_operation(servant, *definitions) 
    4547      end 
    4648    end 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedClient.rb

    r1520 r1574  
    55obj = Echo_version_port_type.new(endpoint_url) 
    66 
    7 # Uncomment the below line to see SOAP wiredumps. 
    8 # obj.wiredump_dev = STDERR 
     7# run ruby with -d to see SOAP wiredumps. 
     8obj.wiredump_dev = STDERR if $DEBUG 
    99 
    1010# SYNOPSIS 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedDriver.rb

    r1532 r1574  
    1515 
    1616  Methods = [ 
    17     ["echo_version", "echo_version", 
    18       [ 
    19         ["in", "version", ["::SOAP::SOAPString"]], 
    20         ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] 
    21       ], 
    22       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     17    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version"), 
     18      "urn:example.com:simpletype-rpc", 
     19      "echo_version", 
     20      [ ["in", "version", ["::SOAP::SOAPString"]], 
     21        ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] ], 
     22      { :request_style =>  :rpc, :request_use =>  :encoded, 
     23        :response_style => :rpc, :response_use => :encoded } 
    2324    ], 
    24     ["echo_version_r", "echo_version_r", 
    25       [ 
    26         ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
    27         ["retval", "version", ["::SOAP::SOAPString"]] 
    28       ], 
    29       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     25    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version_r"), 
     26      "urn:example.com:simpletype-rpc", 
     27      "echo_version_r", 
     28      [ ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
     29        ["retval", "version", ["::SOAP::SOAPString"]] ], 
     30      { :request_style =>  :rpc, :request_use =>  :encoded, 
     31        :response_style => :rpc, :response_use => :encoded } 
    3032    ] 
    3133  ] 
    …… 
    4143 
    4244  def init_methods 
    43     Methods.each do |name_as, name, params, soapaction, namespace, style| 
    44       qname = XSD::QName.new(namespace, name_as) 
    45       if style == :document 
    46         @proxy.add_document_method(soapaction, name, params) 
    47         add_document_method_interface(name, params) 
     45    Methods.each do |definitions| 
     46      opt = definitions.last 
     47      if opt[:request_style] == :document 
     48        add_document_operation(*definitions) 
    4849      else 
    49         @proxy.add_rpc_method(qname, soapaction, name, params) 
    50         add_rpc_method_interface(name, params) 
    51       end 
    52       if name_as != name and name_as.capitalize == name.capitalize 
    53         ::SOAP::Mapping.define_singleton_method(self, name_as) do |*arg| 
    54           __send__(name, *arg) 
     50        add_rpc_operation(*definitions) 
     51        qname = definitions[0] 
     52        name = definitions[2] 
     53        if qname.name != name and qname.name.capitalize == name.capitalize 
     54          ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg| 
     55            __send__(name, *arg) 
     56          end 
    5557        end 
    5658      end 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedService.cgi

    r1532 r1574  
    1616 
    1717  Methods = [ 
    18     ["echo_version", "echo_version", 
    19       [ 
    20         ["in", "version", ["::SOAP::SOAPString"]], 
    21         ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] 
    22       ], 
    23       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     18    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version"), 
     19      "urn:example.com:simpletype-rpc", 
     20      "echo_version", 
     21      [ ["in", "version", ["::SOAP::SOAPString"]], 
     22        ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] ], 
     23      { :request_style =>  :rpc, :request_use =>  :encoded, 
     24        :response_style => :rpc, :response_use => :encoded } 
    2425    ], 
    25     ["echo_version_r", "echo_version_r", 
    26       [ 
    27         ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
    28         ["retval", "version", ["::SOAP::SOAPString"]] 
    29       ], 
    30       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     26    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version_r"), 
     27      "urn:example.com:simpletype-rpc", 
     28      "echo_version_r", 
     29      [ ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
     30        ["retval", "version", ["::SOAP::SOAPString"]] ], 
     31      { :request_style =>  :rpc, :request_use =>  :encoded, 
     32        :response_style => :rpc, :response_use => :encoded } 
    3133    ] 
    3234  ] 
    …… 
    3739    super(*arg) 
    3840    servant = Echo_version_port_type.new 
    39     Echo_version_port_type::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    40       if style == :document 
    41         @router.add_document_operation(servant, soapaction, name, param_def) 
     41    Echo_version_port_type::Methods.each do |definitions| 
     42      opt = definitions.last 
     43      if opt[:request_style] == :document 
     44        @router.add_document_operation(servant, *definitions) 
    4245      else 
    43         qname = XSD::QName.new(namespace, name_as) 
    44         @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     46        @router.add_rpc_operation(servant, *definitions) 
    4547      end 
    4648    end 

  • trunk/test/wsdl/soap/wsdl2ruby/expectedService.rb

    r1532 r1574  
    1616 
    1717  Methods = [ 
    18     ["echo_version", "echo_version", 
    19       [ 
    20         ["in", "version", ["::SOAP::SOAPString"]], 
    21         ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] 
    22       ], 
    23       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     18    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version"), 
     19      "urn:example.com:simpletype-rpc", 
     20      "echo_version", 
     21      [ ["in", "version", ["::SOAP::SOAPString"]], 
     22        ["retval", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]] ], 
     23      { :request_style =>  :rpc, :request_use =>  :encoded, 
     24        :response_style => :rpc, :response_use => :encoded } 
    2425    ], 
    25     ["echo_version_r", "echo_version_r", 
    26       [ 
    27         ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
    28         ["retval", "version", ["::SOAP::SOAPString"]] 
    29       ], 
    30       "urn:example.com:simpletype-rpc", "urn:example.com:simpletype-rpc", :rpc 
     26    [ XSD::QName.new("urn:example.com:simpletype-rpc", "echo_version_r"), 
     27      "urn:example.com:simpletype-rpc", 
     28      "echo_version_r", 
     29      [ ["in", "version_struct", ["Version_struct", "urn:example.com:simpletype-rpc-type", "version_struct"]], 
     30        ["retval", "version", ["::SOAP::SOAPString"]] ], 
     31      { :request_style =>  :rpc, :request_use =>  :encoded, 
     32        :response_style => :rpc, :response_use => :encoded } 
    3133    ] 
    3234  ] 
    …… 
    3739    super(*arg) 
    3840    servant = Echo_version_port_type.new 
    39     Echo_version_port_type::Methods.each do |name_as, name, param_def, soapaction, namespace, style| 
    40       if style == :document 
    41         @router.add_document_operation(servant, soapaction, name, param_def) 
     41    Echo_version_port_type::Methods.each do |definitions| 
     42      opt = definitions.last 
     43      if opt[:request_style] == :document 
     44        @router.add_document_operation(servant, *definitions) 
    4245      else 
    43         qname = XSD::QName.new(namespace, name_as) 
    44         @router.add_rpc_operation(servant, qname, soapaction, name, param_def) 
     46        @router.add_rpc_operation(servant, *definitions) 
    4547      end 
    4648    end