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

Changeset 1790

Show
Ignore:
Timestamp:
05/20/07 17:42:49 (2 years ago)
Author:
nahi
Message:
  • classDefCreator wrongly generated element definitions. fixed.
  • let tests use module_path to reduce 're-opens' warning.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1788 r1790  
    5353        return found if found 
    5454      else 
    55         return ele if ele.elename == qname 
     55        # relaxed match 
     56        if ele.elename == qname or 
     57            (qname.namespace.nil? and ele.elename.name == qname.name) 
     58          return ele 
     59        end 
    5660      end 
    5761    end 

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

    r1788 r1790  
    8585      elsif ele.local_simpletype 
    8686        dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
    87       elsif ele.type 
    88         if @complextypes[ele.type] 
    89           dump_complextypedef(ele.name, @complextypes[ele.type], qualified) 
    90         elsif @simpletypes[ele.type] 
    91           dump_simpletypedef(ele.name, @simpletypes[ele.type], qualified) 
    92         else 
    93           nil 
    94         end 
    9587      else 
    9688        nil 
    …… 
    138130    end 
    139131    classname = create_class_name(qname) 
    140     if Module.constants.include?(classname) 
    141       warn("created definition tries to reopen existing class: #{classname}") 
    142     end 
     132    check_classname(classname) 
    143133    c = ClassDef.new(classname, '::String') 
    144134    c.comment = "#{qname}" 
    …… 
    150140    list = typedef.list 
    151141    classname = create_class_name(qname) 
    152     if Module.constants.include?(classname) 
    153       warn("created definition tries to reopen existing class: #{classname}") 
    154     end 
     142    check_classname(classname) 
    155143    c = ClassDef.new(classname, '::Array') 
    156144    c.comment = "#{qname}" 
    …… 
    207195  def dump_simpleclassdef(qname, type_or_element) 
    208196    classname = create_class_name(qname) 
    209     if Module.constants.include?(classname) 
    210       warn("created definition tries to reopen existing class: #{classname}") 
    211     end 
     197    check_classname(classname) 
    212198    c = ClassDef.new(classname, '::String') 
    213199    c.comment = "#{qname}" 
    …… 
    242228  def dump_classdef(qname, typedef, qualified = false) 
    243229    classname = create_class_name(qname) 
     230    check_classname(classname) 
    244231    baseclassname = nil 
    245232    if typedef.complexcontent 
    …… 
    247234        baseclassname = create_class_name(base) 
    248235      end 
    249     end 
    250     if Module.constants.include?(classname) 
    251       warn("created definition tries to reopen existing class: #{classname}") 
    252236    end 
    253237    if @faulttypes and @faulttypes.index(qname) 
    …… 
    373357  def dump_arraydef(qname, complextype) 
    374358    classname = create_class_name(qname) 
    375     if Module.constants.include?(classname) 
    376       warn("created definition tries to reopen existing class: #{classname}") 
    377     end 
     359    check_classname(classname) 
    378360    c = ClassDef.new(classname, '::Array') 
    379361    c.comment = "#{qname}" 
    380362    c.dump 
     363  end 
     364 
     365  def check_classname(classname) 
     366    if @modulepath.nil? and Module.constants.include?(classname) 
     367      warn("created definition re-opens an existing toplevel class: #{classname}") 
     368    end 
    381369  end 
    382370end 

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

    r1788 r1790  
    6767      elsif ele.local_simpletype 
    6868        dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
    69       elsif ele.type 
    70         if @complextypes[ele.type] 
    71           dump_complextypedef(ele.name, @complextypes[ele.type], qualified) 
    72         elsif @simpletypes[ele.type] 
    73           dump_simpletypedef(ele.name, @simpletypes[ele.type], qualified) 
    74         else 
    75           nil 
    76         end 
    7769      else 
    7870        nil 

  • trunk/test/wsdl/abstract/test_abstract.rb

    r1774 r1790  
    5959    gen.opt['classdef'] = nil 
    6060    gen.opt['mapping_registry'] = nil 
     61    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    6162    gen.opt['driver'] = nil 
    6263    gen.opt['force'] = true 

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

    r1771 r1790  
    11require 'echo.rb' 
    22require 'echoMappingRegistry.rb' 
     3 
     4module WSDL::Any 
    35require 'soap/rpc/driver' 
    46 
    …… 
    5456end 
    5557 
     58 
     59end 

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

    r1788 r1790  
    11require 'xsd/qname' 
    22 
    3 # {urn:example.com:echo-type}foo.bar 
    4 class FooBar 
    5   attr_accessor :before 
    6   attr_reader :__xmlele_any 
    7   attr_accessor :after 
     3module WSDL::Any 
    84 
    9   def set_any(elements) 
    10     @__xmlele_any = elements 
    11   end 
    12  
    13   def initialize(before = nil, after = nil) 
    14     @before = before 
    15     @__xmlele_any = nil 
    16     @after = after 
    17   end 
    18 end 
    195 
    206# {urn:example.com:echo-type}foo.bar 
    …… 
    4733  end 
    4834end 
     35 
     36 
     37end 

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

    r1771 r1790  
    33require 'echoMappingRegistry.rb' 
    44require 'soap/rpc/standaloneServer' 
     5 
     6module WSDL; module Any 
    57 
    68class Echo_port_type 
    …… 
    2527end 
    2628 
     29end; end 
     30 
     31module WSDL; module Any 
     32 
    2733class Echo_port_typeApp < ::SOAP::RPC::StandaloneServer 
    2834  def initialize(*arg) 
    2935    super(*arg) 
    30     servant = Echo_port_type.new 
    31     Echo_port_type::Methods.each do |definitions| 
     36    servant = WSDL::Any::Echo_port_type.new 
     37    WSDL::Any::Echo_port_type::Methods.each do |definitions| 
    3238      opt = definitions.last 
    3339      if opt[:request_style] == :document 
    …… 
    4248end 
    4349 
     50end; end 
     51 
    4452if $0 == __FILE__ 
    4553  # Change listen port. 
    46   server = Echo_port_typeApp.new('app', nil, '0.0.0.0', 10080) 
     54  server = WSDL::Any::Echo_port_typeApp.new('app', nil, '0.0.0.0', 10080) 
    4755  trap(:INT) do 
    4856    server.shutdown 

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

    r1755 r1790  
    8484    gen.opt['classdef'] = nil 
    8585    gen.opt['mapping_registry'] = nil 
     86    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    8687    gen.opt['driver'] = nil 
    8788    gen.opt['force'] = true 
    …… 
    122123    gen.basedir = DIR 
    123124    gen.logger.level = Logger::FATAL 
     125    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    124126    gen.opt['classdef'] = nil 
    125127    gen.opt['mapping_registry'] = nil 
    …… 
    132134      gen.run 
    133135    end 
     136    compare("expectedEcho.rb", "echo.rb") 
    134137    compare("expectedDriver.rb", "echoDriver.rb") 
    135     compare("expectedEcho.rb", "echo.rb") 
    136138    compare("expectedService.rb", "echo_service.rb") 
    137139 

  • trunk/test/wsdl/choice/choice.wsdl

    r1788 r1790  
    5555      </xsd:element> 
    5656 
    57       <xsd:element name="echoele_complex" type="tns:andor" /> 
    58       <xsd:element name="echo_complex_response" type="tns:andor" /> 
     57      <xsd:element name="echoele_complex"> 
     58        <xsd:complexType> 
     59          <xsd:sequence> 
     60            <xsd:element name="data" type="tns:andor"/> 
     61          </xsd:sequence> 
     62        </xsd:complexType> 
     63      </xsd:element> 
     64 
     65      <xsd:element name="echo_complex_response"> 
     66        <xsd:complexType> 
     67          <xsd:sequence> 
     68            <xsd:element name="data" type="tns:andor"/> 
     69          </xsd:sequence> 
     70        </xsd:complexType> 
     71      </xsd:element> 
    5972    </xsd:schema> 
    6073  </types> 

  • trunk/test/wsdl/choice/test_choice.rb

    r1788 r1790  
    3636 
    3737    def echo_complex(arg) 
    38       p arg 
    39       arg 
     38      Echo_complex_response.new(arg.data) 
    4039    end 
    4140  end 
    …… 
    7473    gen.opt['classdef'] = nil 
    7574    gen.opt['mapping_registry'] = nil 
     75    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    7676    gen.opt['driver'] = nil 
    7777    gen.opt['force'] = true 
    …… 
    153153    @client.literal_mapping_registry = ChoiceMappingRegistry::LiteralRegistry 
    154154    # 
    155     ret = @client.echo_complex(Andor.new("A", "B1", nil, nil, nil, nil, "C1", "C2")) 
    156     assert_equal("A", ret.a) 
    157     assert_equal("B1", ret.b1) 
    158     assert_equal(nil, ret.b2a) 
    159     assert_equal(nil, ret.b2b) 
    160     assert_equal(nil, ret.b3a) 
    161     assert_equal(nil, ret.b3b) 
    162     assert_equal("C1", ret.c1) 
    163     assert_equal("C2", ret.c2) 
     155    ret = @client.echo_complex(Echoele_complex.new(Andor.new("A", "B1", nil, nil, nil, nil, "C1", "C2"))) 
     156    assert_equal("A", ret.data.a) 
     157    assert_equal("B1", ret.data.b1) 
     158    assert_equal(nil, ret.data.b2a) 
     159    assert_equal(nil, ret.data.b2b) 
     160    assert_equal(nil, ret.data.b3a) 
     161    assert_equal(nil, ret.data.b3b) 
     162    assert_equal("C1", ret.data.c1) 
     163    assert_equal("C2", ret.data.c2) 
    164164    # 
    165     ret = @client.echo_complex(Andor.new("A", nil, "B2a", "B2b", nil, nil, "C1", "C2")) 
    166     assert_equal("A", ret.a) 
    167     assert_equal(nil, ret.b1) 
    168     assert_equal("B2a", ret.b2a) 
    169     assert_equal("B2b", ret.b2b) 
    170     assert_equal(nil, ret.b3a) 
    171     assert_equal(nil, ret.b3b) 
    172     assert_equal("C1", ret.c1) 
    173     assert_equal("C2", ret.c2) 
     165    ret = @client.echo_complex(Echoele_complex.new(Andor.new("A", nil, "B2a", "B2b", nil, nil, "C1", "C2"))) 
     166    assert_equal("A", ret.data.a) 
     167    assert_equal(nil, ret.data.b1) 
     168    assert_equal("B2a", ret.data.b2a) 
     169    assert_equal("B2b", ret.data.b2b) 
     170    assert_equal(nil, ret.data.b3a) 
     171    assert_equal(nil, ret.data.b3b) 
     172    assert_equal("C1", ret.data.c1) 
     173    assert_equal("C2", ret.data.c2) 
    174174    # 
    175     ret = @client.echo_complex(Andor.new("A", nil, nil, nil, "B3a", nil, "C1", "C2")) 
    176     assert_equal("A", ret.a) 
    177     assert_equal(nil, ret.b1) 
    178     assert_equal(nil, ret.b2a) 
    179     assert_equal(nil, ret.b2b) 
    180     assert_equal("B3a", ret.b3a) 
    181     assert_equal(nil, ret.b3b) 
    182     assert_equal("C1", ret.c1) 
    183     assert_equal("C2", ret.c2) 
     175    ret = @client.echo_complex(Echoele_complex.new(Andor.new("A", nil, nil, nil, "B3a", nil, "C1", "C2"))) 
     176    assert_equal("A", ret.data.a) 
     177    assert_equal(nil, ret.data.b1) 
     178    assert_equal(nil, ret.data.b2a) 
     179    assert_equal(nil, ret.data.b2b) 
     180    assert_equal("B3a", ret.data.b3a) 
     181    assert_equal(nil, ret.data.b3b) 
     182    assert_equal("C1", ret.data.c1) 
     183    assert_equal("C2", ret.data.c2) 
    184184    # 
    185     ret = @client.echo_complex(Andor.new("A", nil, nil, nil, nil, "B3b", "C1", "C2")) 
    186     assert_equal("A", ret.a) 
    187     assert_equal(nil, ret.b1) 
    188     assert_equal(nil, ret.b2a) 
    189     assert_equal(nil, ret.b2b) 
    190     assert_equal(nil, ret.b3a) 
    191     assert_equal("B3b", ret.b3b) 
    192     assert_equal("C1", ret.c1) 
    193     assert_equal("C2", ret.c2) 
     185    ret = @client.echo_complex(Echoele_complex.new(Andor.new("A", nil, nil, nil, nil, "B3b", "C1", "C2"))) 
     186    assert_equal("A", ret.data.a) 
     187    assert_equal(nil, ret.data.b1) 
     188    assert_equal(nil, ret.data.b2a) 
     189    assert_equal(nil, ret.data.b2b) 
     190    assert_equal(nil, ret.data.b3a) 
     191    assert_equal("B3b", ret.data.b3b) 
     192    assert_equal("C1", ret.data.c1) 
     193    assert_equal("C2", ret.data.c2) 
    194194  end 
    195195end 

  • trunk/test/wsdl/document/array/test_array.rb

    r1756 r1790  
    6161    gen.opt['classdef'] = nil 
    6262    gen.opt['mapping_registry'] = nil 
     63    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    6364    gen.opt['force'] = true 
    6465    gen.run 

  • trunk/test/wsdl/fault/test_fault.rb

    r1754 r1790  
    5050    gen.basedir = DIR 
    5151    gen.logger.level = Logger::FATAL 
     52    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    5253    gen.opt['classdef'] = nil 
    5354    gen.opt['mapping_registry'] = nil 
    …… 
    124125    rescue Exception => e 
    125126      assert_equal(::SOAP::FaultError, e.class) 
    126       assert_equal("AddFault", e.faultstring.data) 
     127      assert_equal("WSDL::Fault::AddFault", e.faultstring.data) 
    127128      assert_equal("Value 101 is too large", e.detail.addFault.reason) 
    128129      assert_equal("Critical", e.detail.addFault.severity) 

  • trunk/test/wsdl/fault/test_multifault.rb

    r1754 r1790  
    5656    gen.basedir = DIR 
    5757    gen.logger.level = Logger::FATAL 
     58    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    5859    gen.opt['classdef'] = nil 
    5960    gen.opt['mapping_registry'] = nil 
    …… 
    130131    rescue Exception => e 
    131132      assert_equal(::SOAP::FaultError, e.class) 
    132       assert_equal("AddFault", e.faultstring.data) 
     133      assert_equal("WSDL::Fault::AddFault", e.faultstring.data) 
    133134      assert_equal("Value 101 is too large", e.detail.addFault.reason) 
    134135      assert_equal("Critical", e.detail.addFault.severity) 
    …… 
    139140    rescue Exception => e 
    140141      assert_equal(::SOAP::FaultError, e.class) 
    141       assert_equal("NegativeValueFault", e.faultstring.data) 
     142      assert_equal("WSDL::Fault::NegativeValueFault", e.faultstring.data) 
    142143      assert_equal("Value -50 is negative", e.detail.negativeValueFault.reason) 
    143144      assert_equal("Fatal", e.detail.negativeValueFault.severity) 

  • trunk/test/wsdl/list/test_list.rb

    r1755 r1790  
    5757    gen.basedir = DIR 
    5858    gen.logger.level = Logger::FATAL 
     59    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    5960    gen.opt['classdef'] = nil 
    6061    gen.opt['mapping_registry'] = nil 

  • trunk/test/wsdl/marshal/test_wsdlmarshal.rb

    r1731 r1790  
    55require 'wsdl/soap/wsdl2ruby' 
    66 
     7 
    78class WSDLMarshaller 
    8   include SOAP 
    9  
    109  def initialize(wsdlfile) 
    1110    wsdl = WSDL::Parser.new.parse(File.open(wsdlfile) { |f| f.read }) 
    …… 
    1615      :pretty => true 
    1716    } 
    18     @mapping_registry = Mapping::WSDLEncodedRegistry.new(types) 
     17    @mapping_registry = ::SOAP::Mapping::WSDLEncodedRegistry.new(types) 
    1918  end 
    2019 
    2120  def dump(obj, io = nil) 
    22     ele =  Mapping.obj2soap(obj, @mapping_registry) 
     21    ele =  ::SOAP::Mapping.obj2soap(obj, @mapping_registry) 
    2322    ele.elename = ele.type 
    24     Processor.marshal(SOAPEnvelope.new(nil, SOAPBody.new(ele)), @opt, io) 
     23    ::SOAP::Processor.marshal(::SOAP::SOAPEnvelope.new(nil, ::SOAP::SOAPBody.new(ele)), @opt, io) 
    2524  end 
    2625 
    2726  def load(io) 
    28     header, body = Processor.unmarshal(io, @opt) 
    29     Mapping.soap2obj(body.root_node) 
     27    header, body = ::SOAP::Processor.unmarshal(io, @opt) 
     28    ::SOAP::Mapping.soap2obj(body.root_node) 
    3029  end 
    3130end 

  • trunk/test/wsdl/qualified/test_qualified.rb

    r1756 r1790  
    6161      gen.basedir = DIR 
    6262      gen.logger.level = Logger::FATAL 
     63      gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    6364      gen.opt['classdef'] = nil 
    6465      gen.opt['mapping_registry'] = nil 

  • trunk/test/wsdl/qualified/test_unqualified.rb

    r1756 r1790  
    6161      gen.basedir = DIR 
    6262      gen.logger.level = Logger::FATAL 
     63      gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    6364      gen.opt['classdef'] = nil 
    6465      gen.opt['mapping_registry'] = nil 

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

    r1756 r1790  
    11require 'product.rb' 
    22require 'productMappingRegistry.rb' 
     3 
     4module WSDL::Ref 
    35require 'soap/rpc/driver' 
    46 
    …… 
    4648end 
    4749 
     50 
     51end 

  • trunk/test/wsdl/ref/test_ref.rb

    r1756 r1790  
    8383    gen.basedir = DIR 
    8484    gen.logger.level = Logger::FATAL 
     85    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    8586    gen.opt['classdef'] = nil 
    8687    gen.opt['mapping_registry'] = nil 

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

    r1788 r1790  
    123123    gen.basedir = DIR 
    124124    gen.logger.level = Logger::FATAL 
     125    gen.opt['module_path'] = self.class.to_s.sub(/::[^:]+$/, '') 
    125126    gen.opt['classdef'] = nil 
    126127    gen.opt['mapping_registry'] = nil 
    …… 
    322323    assert_equal('+1', result.varFloat) 
    323324    assert_equal('str', result.structItem.varString) 
    324     assert_equal(1, result.structItem.varInt) 
    325     assert_equal(1.0, result.structItem.varFloat) 
     325    assert_equal('1', result.structItem.varInt) 
     326    assert_equal('+1', result.structItem.varFloat) 
    326327    assert_equal(ECHO_NESTED_STRUCT_REQUEST, parse_requestxml(str)) 
    327328    assert_equal(ECHO_NESTED_STRUCT_RESPONSE, parse_responsexml(str))