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

Changeset 1731

Show
Ignore:
Timestamp:
10/01/06 23:14:27 (2 years ago)
Author:
nahi
Message:

moved @@schema_* things in classdef definition to mapping registry. Mapping registries for each classdef are defined in independent file and required from driver and server.
NOTE: old classdef files should still work but it should be re-generated by new wsdl2ruby.rb.
closes #175, #267.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/bin/wsdl2ruby.rb

    r1654 r1731  
    1111  OptSet = [ 
    1212    ['--wsdl','-w', GetoptLong::REQUIRED_ARGUMENT], 
     13    ['--module_path','-m', GetoptLong::REQUIRED_ARGUMENT], 
    1314    ['--type','-t', GetoptLong::REQUIRED_ARGUMENT], 
    1415    ['--classdef','-e', GetoptLong::OPTIONAL_ARGUMENT], 
     16    ['--mapping_registry','-r', GetoptLong::OPTIONAL_ARGUMENT], 
    1517    ['--client_skelton','-c', GetoptLong::OPTIONAL_ARGUMENT], 
    1618    ['--servant_skelton','-s', GetoptLong::OPTIONAL_ARGUMENT], 
     
    6062    --type server implies; 
    6163        --classdef 
     64        --mapping_registry 
    6265        --servant_skelton 
    6366        --standalone_server_stub 
    6467    --type client implies; 
    6568        --classdef 
     69        --mapping_registry 
    6670        --client_skelton 
    6771        --driver 
    6872  --classdef 
     73  --mapping_registry 
    6974  --client_skelton [servicename] 
    7075  --servant_skelton [porttypename] 
     
    7277  --standalone_server_stub [servicename] 
    7378  --driver [porttypename] 
     79  --module_path [Module::Path::Name] 
    7480  --force 
    7581  --quiet 
     
    9298        when "--wsdl" 
    9399          wsdl = arg 
     100        when "--module_path" 
     101          opt['module_path'] = arg 
    94102        when "--type" 
    95103          case arg 
    96104          when "server" 
    97105            opt['classdef'] = nil 
     106            opt['mapping_registry'] = nil 
    98107            opt['servant_skelton'] = nil 
    99108            opt['standalone_server_stub'] = nil 
    100109          when "client" 
    101110            opt['classdef'] = nil 
     111            opt['mapping_registry'] = nil 
    102112            opt['driver'] = nil 
    103113            opt['client_skelton'] = nil 
     
    105115            raise ArgumentError.new("Unknown type #{ arg }") 
    106116          end 
    107         when "--classdef", "--client_skelton", "--servant_skelton", 
    108             "--cgi_stub", "--standalone_server_stub", "--driver" 
     117        when "--classdef", "--mapping_registry", 
     118            "--client_skelton", "--servant_skelton", 
     119            "--cgi_stub", "--standalone_server_stub", 
     120            "--driver" 
    109121          opt[name.sub(/^--/, '')] = arg.empty? ? nil : arg 
    110122        when "--force" 
  • trunk/lib/soap/mapping.rb

    r1520 r1731  
    99require 'soap/mapping/mapping' 
    1010require 'soap/mapping/registry' 
     11require 'soap/mapping/encodedregistry' 
     12require 'soap/mapping/literalregistry' 
  • trunk/lib/soap/mapping/encodedregistry.rb

    r1720 r1731  
    4848 
    4949class EncodedRegistry 
     50  include TraverseSupport 
     51  include RegistrySupport 
     52 
    5053  class Map 
    5154    def initialize(registry) 
     
    137140    [::TrueClass,    ::SOAP::SOAPBoolean,    BasetypeFactory], 
    138141    [::FalseClass,   ::SOAP::SOAPBoolean,    BasetypeFactory], 
    139     [::String,       ::SOAP::SOAPString,     StringFactory], 
     142    [::String,       ::SOAP::SOAPString,     StringFactory, 
     143      {:derived_class => true}], 
    140144    [::DateTime,     ::SOAP::SOAPDateTime,   DateTimeFactory], 
    141145    [::Date,         ::SOAP::SOAPDate,       DateTimeFactory], 
     
    264268 
    265269  def initialize(config = {}) 
     270    super() 
    266271    @config = config 
    267272    @map = Map.new(self) 
     
    284289  end 
    285290 
     291  # initial mapping interface 
     292  # new interface Registry#register is defined in RegisterSupport 
    286293  def add(obj_class, soap_class, factory, info = nil) 
    287294    @map.add(obj_class, soap_class, factory, info) 
     
    328335    end 
    329336    begin  
     337      if definition = schema_definition_from_class(obj.class) 
     338        return stubobj2soap(obj, definition) 
     339      end 
    330340      ret = @map.obj2soap(obj) || 
    331341        @default_factory.obj2soap(nil, obj, nil, self) 
     
    344354  # Might return nil as a mapping result. 
    345355  def _soap2obj(node, klass = nil) 
     356    if klass 
     357      definition = schema_definition_from_class(klass) 
     358    else 
     359      if definition = schema_definition_from_elename(node.elename) 
     360        klass = definition.class_for 
     361      elsif definition = schema_definition_from_type(node.type) 
     362        klass = definition.class_for 
     363      end 
     364    end 
     365    if definition 
     366      conv, obj = soap2stubobj(node, klass, definition) 
     367    end 
     368    return obj if conv 
    346369    if node.extraattr.key?(RubyTypeName) 
    347370      conv, obj = @rubytype_factory.soap2obj(nil, node, nil, self) 
    348371      return obj if conv 
    349     else 
    350       conv, obj = @map.soap2obj(node, klass) 
    351       return obj if conv 
    352       conv, obj = @default_factory.soap2obj(nil, node, nil, self) 
    353       return obj if conv 
    354     end 
     372    end 
     373    conv, obj = @map.soap2obj(node, klass) 
     374    return obj if conv 
     375    conv, obj = @default_factory.soap2obj(nil, node, nil, self) 
     376    return obj if conv 
    355377    if @excn_handler_soap2obj 
    356378      begin 
     
    404426    end 
    405427  end 
     428 
     429  def stubobj2soap(obj, definition) 
     430    case obj 
     431    when ::Array 
     432      array2soap(obj, definition) 
     433    else 
     434      return unknownstubobj2soap(obj, definition) 
     435    end 
     436  end 
     437 
     438  def array2soap(obj, definition) 
     439    return SOAPNil.new if obj.nil?      # ToDo: check nillable. 
     440    arytype = definition.elements[0].elename 
     441    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype) 
     442    mark_marshalled_obj(obj, soap_obj) 
     443    obj.each do |item| 
     444      soap_obj.add(Mapping._obj2soap(item, self, arytype)) 
     445    end 
     446    soap_obj 
     447  end 
     448 
     449  def unknownstubobj2soap(obj, definition) 
     450    return SOAPNil.new if obj.nil? 
     451    if definition.elements.size == 0 
     452      qname = XSD::QName.new(definition.ns, definition.name) 
     453      ele = Mapping.obj2soap(obj) 
     454      ele.elename = qname 
     455      return ele 
     456    else 
     457      typename = XSD::QName.new(definition.ns, definition.type) 
     458      ele = SOAPStruct.new(typename) 
     459      mark_marshalled_obj(obj, ele) 
     460    end 
     461    definition.elements.each do |eledef| 
     462      name = eledef.elename.name 
     463      if child = Mapping.get_attribute(obj, eledef.varname) 
     464        if eledef.as_array? 
     465          child.each do |item| 
     466            ele.add(name, Mapping._obj2soap(item, self)) 
     467          end 
     468        else 
     469          ele.add(name, Mapping._obj2soap(child, self)) 
     470        end 
     471      elsif obj.respond_to?(:each) and eledef.as_array? 
     472        obj.each do |item| 
     473          ele.add(name, Mapping._obj2soap(item, self)) 
     474        end 
     475      end 
     476    end 
     477    ele 
     478  end 
     479 
     480  def soap2stubobj(node, obj_class, definition) 
     481    return false unless node.is_a?(::SOAP::SOAPStruct) 
     482    obj = Mapping.create_empty_object(obj_class) 
     483    vars = {} 
     484    node.each do |name, value| 
     485      item = definition.elements.find { |k, v| k.elename.name == name } 
     486      if item 
     487        child = soap2typedobj(value, item.type) 
     488      else 
     489        child = Mapping._soap2obj(value, self) 
     490      end 
     491      if item and item.as_array? 
     492        (vars[name] ||= []) << child 
     493      else 
     494        vars[name] = child 
     495      end 
     496    end 
     497    if obj.is_a?(::Array) 
     498      obj.replace(vars.values.flatten) 
     499    else 
     500      Mapping.set_attributes(obj, vars) 
     501    end 
     502    return true, obj 
     503  end 
     504 
     505  def soap2typedobj(value, typename) 
     506    if klass = Mapping.class_from_name(typename) 
     507      if klass.ancestors.include?(::SOAP::SOAPBasetype) 
     508        if value.respond_to?(:data) 
     509          obj = klass.new(value.data).data 
     510        else 
     511          obj = klass.new(nil).data 
     512        end 
     513      else 
     514        obj = Mapping._soap2obj(value, self, klass) 
     515      end 
     516    elsif klass = Mapping.module_from_name(eledef.type) 
     517      # simpletype 
     518      if value.respond_to?(:data) 
     519        obj = value.data 
     520      else 
     521        raise MappingError.new("cannot map to a module value: #{eledef.type}") 
     522      end 
     523    else 
     524      raise MappingError.new("unknown class/module: #{eledef.type}") 
     525    end 
     526    obj 
     527  end 
    406528end 
     529 
     530 
     531Registry = EncodedRegistry 
     532DefaultRegistry = EncodedRegistry.new 
     533RubyOriginalRegistry = EncodedRegistry.new(:allow_original_mapping => true) 
    407534 
    408535 
  • trunk/lib/soap/mapping/literalregistry.rb

    r1724 r1731  
    2828    @excn_handler_obj2soap = nil 
    2929    @excn_handler_soap2obj = nil 
    30     @class_schema_definition = {} 
    31     @elename_schema_definition = {} 
    32     @type_schema_definition = {} 
    33   end 
    34  
    35   def add(obj_class, definition) 
    36     definition = Mapping.create_schema_definition(obj_class, definition) 
    37     @class_schema_definition[obj_class] = definition 
    38     if definition.name 
    39       qname = XSD::QName.new(definition.ns, definition.name) 
    40       @elename_schema_definition[qname] = definition 
    41     end 
    42     if definition.type 
    43       qname = XSD::QName.new(definition.ns, definition.type) 
    44       @type_schema_definition[qname] = definition 
    45     end 
    4630  end 
    4731 
     
    7862      end 
    7963    end 
    80     if node.respond_to?(:type) 
    81       raise MappingError.new("cannot map #{node.type.name} to Ruby object") 
    82     else 
    83       raise MappingError.new("cannot map #{node.elename.name} to Ruby object") 
    84     end 
     64    raise MappingError.new("cannot map #{node.elename.name}/#{node.type.name} to Ruby object") 
    8565  end 
    8666 
     
    152132          ele.add(obj2soap(item, eledef.elename)) 
    153133        end 
     134      end 
     135    end 
     136    if definition.attributes 
     137      definition.attributes.each do |qname, param| 
     138        at = obj.__send__( 
     139          XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name)) 
     140        ele.extraattr[qname] = at 
    154141      end 
    155142    end 
     
    338325    end 
    339326  end 
    340  
    341   def schema_definition_from_class(klass) 
    342     @class_schema_definition[klass] || Mapping.schema_definition_classdef(klass) 
    343   end 
    344  
    345   def schema_definition_from_elename(qname) 
    346     @elename_schema_definition[qname] || find_schema_definition(qname.name) 
    347   end 
    348  
    349   def schema_definition_from_type(type) 
    350     @type_schema_definition[type] || find_schema_definition(type.name) 
    351   end 
    352  
    353   def find_schema_definition(name) 
    354     typestr = XSD::CodeGen::GenSupport.safeconstname(name) 
    355     obj_class = Mapping.class_from_name(typestr) 
    356     if obj_class 
    357       schema_definition_from_class(obj_class) 
    358     end 
    359   end 
    360327end 
    361328 
  • trunk/lib/soap/mapping/registry.rb

    r1725 r1731  
    99require 'soap/baseData' 
    1010require 'soap/mapping/mapping' 
    11 require 'soap/mapping/encodedregistry.rb' 
    1211 
    1312 
     
    179178  def initialize 
    180179    super() 
     180    @class_schema_definition = {} 
     181    @elename_schema_definition = {} 
     182    @type_schema_definition = {} 
     183  end 
     184 
     185  def register(definition) 
     186    obj_class = definition[:class] 
     187    definition = Mapping.create_schema_definition(obj_class, definition) 
     188    @class_schema_definition[obj_class] = definition 
     189    if definition.name 
     190      qname = XSD::QName.new(definition.ns, definition.name) 
     191      @elename_schema_definition[qname] = definition 
     192    end 
     193    if definition.type 
     194      qname = XSD::QName.new(definition.ns, definition.type) 
     195      @type_schema_definition[qname] = definition 
     196    end 
     197  end 
     198 
     199  def schema_definition_from_class(klass) 
     200    @class_schema_definition[klass] || Mapping.schema_definition_classdef(klass) 
     201  end 
     202 
     203  def schema_definition_from_elename(qname) 
     204    @elename_schema_definition[qname] || find_schema_definition(qname.name) 
     205  end 
     206 
     207  def schema_definition_from_type(type) 
     208    @type_schema_definition[type] || find_schema_definition(type.name) 
     209  end 
     210 
     211  def find_schema_definition(name) 
     212    return nil unless name 
     213    typestr = XSD::CodeGen::GenSupport.safeconstname(name) 
     214    obj_class = Mapping.class_from_name(typestr) 
     215    if obj_class 
     216      schema_definition_from_class(obj_class) 
     217    end 
    181218  end 
    182219   
     
    211248 
    212249 
    213 Registry = EncodedRegistry 
    214 DefaultRegistry = EncodedRegistry.new 
    215 RubyOriginalRegistry = EncodedRegistry.new(:allow_original_mapping => true) 
    216  
    217  
    218 end 
    219 end 
     250end 
     251end 
  • trunk/lib/soap/mapping/wsdlencodedregistry.rb

    r1720 r1731  
    1818 
    1919 
    20 class WSDLEncodedRegistry < Registry 
    21   include TraverseSupport 
    22   include RegistrySupport 
    23  
     20class WSDLEncodedRegistry < EncodedRegistry 
    2421  attr_reader :definedelements 
    2522  attr_reader :definedtypes 
     
    156153    return SOAPNil.new if obj.nil?      # ToDo: check nillable. 
    157154    soap_obj = SOAPStruct.new(type_qname) 
    158     unless obj.nil? 
    159       mark_marshalled_obj(obj, soap_obj) 
    160       elements2soap(obj, soap_obj, type.elements) 
    161     end 
     155    mark_marshalled_obj(obj, soap_obj) 
     156    elements2soap(obj, soap_obj, type.elements) 
    162157    soap_obj 
    163158  end 
  • trunk/lib/soap/mapping/wsdlliteralregistry.rb

    r1724 r1731  
    3737      soap_obj = obj2elesoap(obj, eledef) 
    3838    elsif type = @definedtypes[qname] 
    39       soap_obj = obj2typesoap(obj, type, true
     39      soap_obj = obj2typesoap(obj, type
    4040    else 
    4141      soap_obj = any2soap(obj, qname) 
  • trunk/lib/soap/rpc/cgistub.rb

    r1528 r1731  
    9494  end 
    9595 
    96   def mapping_registry=(value) 
    97     @router.mapping_registry = value 
     96  def mapping_registry=(mapping_registry) 
     97    @router.mapping_registry = mapping_registry 
     98  end 
     99 
     100  def literal_mapping_registry 
     101    @router.literal_mapping_registry 
     102  end 
     103 
     104  def literal_mapping_registry=(literal_mapping_registry) 
     105    @router.literal_mapping_registry = literal_mapping_registry 
    98106  end 
    99107 
  • trunk/lib/soap/rpc/element.rb

    r1692 r1731  
    126126      data.elename.name = param 
    127127    end 
     128  end 
     129 
     130  def get_paramtypes(names) 
     131    types = [] 
     132    @signature.each do |io_type, name, param_type| 
     133      if param_type && idx = names.index(name) 
     134        types[idx] = XSD::QName.new(param_type[1], param_type[2]) 
     135      end 
     136    end 
     137    types 
    128138  end 
    129139 
  • trunk/lib/soap/rpc/httpserver.rb

    r1671 r1731  
    5959  def mapping_registry=(mapping_registry) 
    6060    @router.mapping_registry = mapping_registry 
     61  end 
     62 
     63  def literal_mapping_registry 
     64    @router.literal_mapping_registry 
     65  end 
     66 
     67  def literal_mapping_registry=(literal_mapping_registry) 
     68    @router.literal_mapping_registry = literal_mapping_registry 
    6169  end 
    6270 
  • trunk/lib/soap/rpc/proxy.rb

    r1724 r1731  
    464464    def request_rpc_lit(values, mapping_registry, opt) 
    465465      method = @rpc_method_factory.dup 
     466      names = method.input_params 
     467      types = method.get_paramtypes(names) 
    466468      params = {} 
    467469      idx = 0 
    468       method.input_params.each do |name| 
     470      names.each do |name| 
    469471        params[name] = Mapping.obj2soap(values[idx], mapping_registry,  
    470           XSD::QName.new(nil, name), opt) 
     472          types[idx] || XSD::QName.new, opt) 
    471473        idx += 1 
    472474      end 
  • trunk/lib/soap/wsdlDriver.rb

    r1717 r1731  
    2727  def initialize(wsdl) 
    2828    @wsdl = import(wsdl) 
    29     @methoddefcreator = WSDL::SOAP::MethodDefCreator.new(@wsdl
     29    @methoddefcreator = WSDL::SOAP::MethodDefCreator.new(@wsdl, nil
    3030  end 
    3131   
  • trunk/lib/wsdl/soap/cgiStubCreator.rb

    r1720 r1731  
    2222  attr_reader :definitions 
    2323 
    24   def initialize(definitions
     24  def initialize(definitions, modulepath = nil
    2525    @definitions = definitions 
     26    @modulepath = modulepath 
    2627  end 
    2728 
     
    4647 
    4748  def dump_porttype(name) 
    48     class_name = create_class_name(name) 
    49     methoddef, types = MethodDefCreator.new(@definitions).dump(name) 
    50     mr_creator = MappingRegistryCreator.new(@definitions) 
     49    class_name = create_class_name(name, @modulepath) 
     50    result = MethodDefCreator.new(@definitions, @modulepath).dump(name) 
     51    methoddef = result[:methoddef] 
     52    wsdl_name = @definitions.name ? @definitions.name.name : 'default' 
     53    mrname = safeconstname(wsdl_name + 'MappingRegistry') 
    5154    c1 = XSD::CodeGen::ClassDef.new(class_name) 
    5255    c1.def_require("soap/rpc/cgistub") 
    53     c1.def_require("soap/mapping/registry") 
    54     c1.def_const("MappingRegistry", "::SOAP::Mapping::EncodedRegistry.new") 
    55     c1.def_code(mr_creator.dump(types)) 
    5656    c1.def_code <<-EOD 
    5757Methods = [ 
     
    7373          end 
    7474        end 
    75         self.mapping_registry = #{class_name}::MappingRegistry 
     75        self.mapping_registry = #{mrname}::EncodedRegistry 
     76        self.literal_mapping_registry = #{mrname}::LiteralRegistry 
    7677        self.level = Logger::Severity::ERROR 
    7778      EOD 
  • trunk/lib/wsdl/soap/classDefCreator.rb

    r1724 r1731  
    2020  include XSD::CodeGen 
    2121 
    22   def initialize(definitions) 
     22  def initialize(definitions, modulepath = nil) 
     23    @definitions = definitions 
     24    @modulepath = modulepath 
    2325    @elements = definitions.collect_elements 
    2426    @elements.uniq! 
     
    3739  def dump(type = nil) 
    3840    result = "require 'xsd/qname'\n" 
     41    if @modulepath 
     42      result << "\n" 
     43      result << @modulepath.collect { |ele| "module #{ele}" }.join("; ") 
     44      result << "\n\n" 
     45    end 
    3946    if type 
    4047      result << dump_classdef(type.name, type) 
     
    6067        result << str 
    6168      end 
     69    end 
     70    if @modulepath 
     71      result << "\n\n" 
     72      result << @modulepath.collect { |ele| "end" }.join("; ") 
     73      result << "\n" 
    6274    end 
    6375    result 
     
    96108  def dump_complextype 
    97109    @complextypes.collect { |type| 
    98       dump_complextypedef(type.name, type) 
     110      dump_complextypedef(type.name, type) unless type.abstract 
    99111    }.compact.join("\n") 
    100112  end 
     
    121133    if typedef.name.nil? 
    122134      # local simpletype of a element 
    123       c.def_classvar('schema_type', ndq(nil)) 
     135      #c.def_classvar('schema_type', ndq(nil)) 
    124136    else 
    125137      # named simpletype 
    126       c.def_classvar('schema_type', ndq(qname.name)) 
    127     end 
    128     c.def_classvar('schema_ns', ndq(qname.namespace)) 
    129     c.def_classvar('schema_qualified', dq('true')) if qualified 
     138      #c.def_classvar('schema_type', ndq(qname.name)) 
     139    end 
     140    #c.def_classvar('schema_ns', ndq(qname.namespace)) 
     141    #c.def_classvar('schema_qualified', dq('true')) if qualified 
    130142    define_classenum_restriction(c, classname, restriction.enumeration) 
    131143    c.dump 
     
    216228    if typedef.name.nil? 
    217229      # local complextype of a element 
    218       c.def_classvar('schema_type', ndq(nil)) 
     230      #c.def_classvar('schema_type', ndq(nil)) 
    219231    else 
    220232      # named complextype 
    221       c.def_classvar('schema_type', ndq(qname.name)) 
    222     end 
    223     c.def_classvar('schema_ns', ndq(qname.namespace)) 
    224     c.def_classvar('schema_qualified', dq('true')) if qualified 
     233      #c.def_classvar('schema_type', ndq(qname.name)) 
     234    end 
     235    #c.def_classvar('schema_ns', ndq(qname.namespace)) 
     236    #c.def_classvar('schema_qualified', dq('true')) if qualified 
    225237    schema_element, init_lines, init_params = 
    226238      parse_elements(c, typedef.elements, qname.namespace) 
     
    232244      init_lines << "@__xmlattr = {}" 
    233245    end 
    234     c.def_classvar('schema_element', 
    235       dump_schema_element_definition(schema_element, 2) 
    236    
     246    #c.def_classvar('schema_element', 
     247    #  dump_schema_element_definition(schema_element, 2) 
     248    #
    237249    c.def_method('initialize', *init_params) do 
    238250      init_lines.join("\n") 
     
    403415      schema_attribute << [name, type] 
    404416    end 
    405     c.def_classvar('schema_attribute', 
    406       "{\n  " + 
    407         schema_attribute.collect { |name, type| 
    408           dqname(name) + ' => ' + ndq(type) 
    409         }.join(",\n  ") + 
    410       "\n}" 
    411    
     417    #c.def_classvar('schema_attribute', 
     418    #  "{\n  " + 
     419    #    schema_attribute.collect { |name, type| 
     420    #      dqname(name) + ' => ' + ndq(type) 
     421    #    }.join(",\n  ") + 
     422    #  "\n}" 
     423    #
    412424  end 
    413425 
     
    450462    end 
    451463    schema_element << [child_element_name.name, child_element_name, type] 
    452     c.def_classvar('schema_element', 
    453       dump_schema_element_definition(schema_element, 2) 
    454    
     464    #c.def_classvar('schema_element', 
     465    #  dump_schema_element_definition(schema_element, 2) 
     466    #
    455467    c.dump 
    456468  end 
  • trunk/lib/wsdl/soap/classDefCreatorSupport.rb

    r1711 r1731  
    2020  include XSD::CodeGen::GenSupport 
    2121 
    22   def create_class_name(qname
     22  def create_class_name(qname, modulepath = nil
    2323    if klass = basetype_mapped_class(qname) 
    2424      ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
    2525    else 
    26       safeconstname(qname.name) 
     26      name = safeconstname(qname.name) 
     27      if modulepath 
     28        [modulepath, name].join('::') 
     29      else 
     30        name 
     31      end 
    2732    end 
    2833  end 
  • trunk/lib/wsdl/soap/clientSkeltonCreator.rb

    r1711 r1731  
    2020  attr_reader :definitions 
    2121 
    22   def initialize(definitions
     22  def initialize(definitions, modulepath = nil
    2323    @definitions = definitions 
     24    @modulepath = modulepath 
    2425  end 
    2526 
    2627  def dump(service_name) 
    27     result = "" 
    2828    services = @definitions.service(service_name) 
    2929    unless services 
    3030      raise RuntimeError.new("service not defined: #{service_name}") 
    3131    end 
     32    result = "" 
     33    if @modulepath 
     34      result << "\n" 
     35      result << @modulepath.collect { |ele| "module #{ele}" }.join("; ") 
     36      result << "\n\n" 
     37    end 
    3238    services.ports.each do |port| 
    3339      result << dump_porttype(port.porttype.name) 
     40      result << "\n" 
     41    end 
     42    if @modulepath 
     43      result << "\n\n" 
     44      result << @modulepath.collect { |ele| "end" }.join("; ") 
    3445      result << "\n" 
    3546    end 
  • trunk/lib/wsdl/soap/driverCreator.rb

    r1724 r1731  
    99require 'wsdl/info' 
    1010require 'wsdl/soap/mappingRegistryCreator' 
    11 require 'wsdl/soap/literalMappingRegistryCreator' 
    1211require 'wsdl/soap/methodDefCreator' 
    1312require 'wsdl/soap/classDefCreatorSupport' 
     
    2423  attr_reader :definitions 
    2524 
    26   def initialize(definitions
     25  def initialize(definitions, modulepath = nil
    2726    @definitions = definitions 
     27    @modulepath = modulepath 
    2828  end 
    2929 
    3030  def dump(porttype = nil) 
     31    result = '' 
     32    if @modulepath 
     33      result << "\n" 
     34      @modulepath.each do |name| 
     35        result << "module #{name}\n" 
     36      end 
     37    end 
    3138    if porttype.nil? 
    32       result = "" 
    3339      @definitions.porttypes.each do |type| 
    3440        result << dump_porttype(type.name) 
     
    3642      end 
    3743    else 
    38       result = dump_porttype(porttype) 
     44      result << dump_porttype(porttype) 
     45    end 
     46    if @modulepath 
     47      result << "\n" 
     48      @modulepath.each do |name| 
     49        result << "end\n" 
     50      end 
    3951    end 
    4052    result 
     
    4557  def dump_porttype(porttype) 
    4658    class_name = create_class_name(porttype) 
    47     methoddef, methodtypes = MethodDefCreator.new(@definitions).dump(porttype) 
    48     mr_creator = MappingRegistryCreator.new(@definitions) 
    49     literal_mr_creator = LiteralMappingRegistryCreator.new(@definitions) 
     59    result = MethodDefCreator.new(@definitions, @modulepath).dump(porttype) 
     60    methoddef = result[:methoddef] 
    5061    binding = @definitions.bindings.find { |item| item.type == porttype } 
    5162    if binding.nil? or binding.soapbinding.nil? 
     
    5768    c = XSD::CodeGen::ClassDef.new(class_name, "::SOAP::RPC::Driver") 
    5869    c.def_require("soap/rpc/driver") 
    59     #c.def_const("EncodedMappingRegistry", "::SOAP::Mapping::EncodedRegistry.new") 
    60     c.def_const("MappingRegistry", "::SOAP::Mapping::EncodedRegistry.new") 
    61     #c.def_const("LiteralMappingRegistry", "::SOAP::Mapping::LiteralRegistry.new") 
    6270    c.def_const("DefaultEndpointUrl", ndq(address)) 
    63     c.def_code(mr_creator.dump(methodtypes)) 
    64     #c.def_code(literal_mr_creator.dump) 
    6571    c.def_code <<-EOD 
    6672Methods = [ 
     
    6874] 
    6975    EOD 
    70         #self.literal_mapping_registry = LiteralMappingRegistry 
     76    wsdl_name = @definitions.name ? @definitions.name.name : 'default' 
     77    mrname = safeconstname(wsdl_name + 'MappingRegistry') 
    7178    c.def_method("initialize", "endpoint_url = nil") do 
    72       <<-EOD 
    73         endpoint_url ||= DefaultEndpointUrl 
    74         super(endpoint_url, nil) 
    75         self.mapping_registry = MappingRegistry 
    76         init_methods 
    77       EOD 
     79      %Q[endpoint_url ||= DefaultEndpointUrl\n] + 
     80      %Q[super(endpoint_url, nil)\n] + 
     81      %Q[self.mapping_registry = #{mrname}::EncodedRegistry\n] + 
     82      %Q[self.literal_mapping_registry = #{mrname}::LiteralRegistry\n] + 
     83      %Q[init_methods] 
    7884    end 
    7985    c.def_privatemethod("init_methods") do 
  • trunk/lib/wsdl/soap/mappingRegistryCreator.rb

    r1721 r1731  
    11# WSDL4R - Creating MappingRegistry code from WSDL. 
    2 # Copyright (C) 2002, 2003, 2005, 2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
     2# Copyright (C) 2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>. 
    33 
    44# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can 
     
    99require 'wsdl/info' 
    1010require 'wsdl/soap/classDefCreatorSupport' 
     11require 'wsdl/soap/encodedMappingRegistryCreator' 
     12require 'wsdl/soap/literalMappingRegistryCreator' 
    1113 
    1214 
     
    2022  attr_reader :definitions 
    2123 
    22   def initialize(definitions
     24  def initialize(definitions, modulepath = nil
    2325    @definitions = definitions 
    24     @complextypes = @definitions.collect_complextypes 
    25     @types = nil 
     26    @modulepath = modulepath 
    2627  end 
    2728 
    28   def dump(types) 
    29     @types = types 
    30     map_cache = [] 
    31     map = "" 
    32     @types.each do |type| 
    33       if map_cache.index(type).nil? 
    34         map_cache << type 
    35         if type.namespace != XSD::Namespace 
    36           if typemap = dump_typemap(type) 
    37             map << typemap 
    38           end 
    39         end 
    40       end 
     29  def dump 
     30    encoded_creator = EncodedMappingRegistryCreator.new(@definitions, @modulepath) 
     31    literal_creator = LiteralMappingRegistryCreator.new(@definitions, @modulepath) 
     32    wsdl_name = @definitions.name ? @definitions.name.name : 'default' 
     33    module_name = safeconstname(wsdl_name + 'MappingRegistry') 
     34    if @modulepath 
     35      module_name = [@modulepath, module_name].join('::') 
    4136    end 
    42     return map 
    43   end 
    44  
    45 private 
    46  
    47   def dump_typemap(type) 
    48     if definedtype = @complextypes[type] 
    49       case definedtype.compoundtype 
    50       when :TYPE_STRUCT 
    51         dump_struct_typemap(definedtype) 
    52       when :TYPE_ARRAY 
    53         dump_array_typemap(definedtype) 
    54       when :TYPE_MAP, :TYPE_EMPTY 
    55         nil 
    56       else 
    57         raise NotImplementedError.new("must not reach here") 
    58       end 
    59     end 
    60   end 
    61  
    62   def dump_struct_typemap(definedtype) 
    63     ele = definedtype.name 
    64     return <<__EOD__ 
    65 MappingRegistry.set( 
    66   #{create_class_name(ele)}, 
    67   ::SOAP::SOAPStruct, 
    6