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

Changeset 1948

Show
Ignore:
Timestamp:
09/10/07 10:28:21 (8 months ago)
Author:
nahi
Message:
  • let ClassNameCreator? handle modulepath. Foo::Baz and Bar::Baz have the same name (Baz) but these are different qnames so there's no need for name crash avoidaidance. closes #413.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1939 r1948  
    4848 
    4949  def dump_porttype(porttype) 
    50     class_name = create_class_name(porttype.name, @modulepath) 
     50    class_name = mapped_class_name(porttype.name, @modulepath) 
    5151    defined_const = {} 
    5252    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name) 

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

    r1944 r1948  
    4444  def dump(type = nil) 
    4545    result = "require 'xsd/qname'\n" 
    46     # cannot use create_class_name with @modulepath because of multiple classes 
     46    # cannot use @modulepath because of multiple classes 
    4747    if @modulepath 
    4848      result << "\n" 
    …… 
    158158      return nil 
    159159    end 
    160     classname = create_class_name(qname) 
     160    classname = mapped_class_basename(qname, @modulepath) 
    161161    check_classname(classname) 
    162162    c = ClassDef.new(classname, '::String') 
    …… 
    168168  def create_simpletypedef_list(qname, typedef, qualified) 
    169169    list = typedef.list 
    170     classname = create_class_name(qname) 
     170    classname = mapped_class_basename(qname, @modulepath) 
    171171    check_classname(classname) 
    172172    c = ClassDef.new(classname, '::Array') 
    …… 
    180180      c.comment << "\n  contains list of #{classname}::*" 
    181181    elsif list.itemtype 
    182       c.comment << "\n  contains list of #{create_class_name(list.itemtype)}::*" 
     182      c.comment << "\n  contains list of #{mapped_class_basename(list.itemtype, @modulepath)}::*" 
    183183    else 
    184184      raise RuntimeError.new("unknown kind of list: #{list}") 
    …… 
    189189  def create_simpletypedef_union(qname, typedef, qualified) 
    190190    union = typedef.union 
    191     classname = create_class_name(qname) 
     191    classname = mapped_class_basename(qname, @modulepath) 
    192192    c = ClassDef.new(classname, '::String') 
    193193    c.comment = "#{qname}" 
    …… 
    224224 
    225225  def create_simpleclassdef(qname, type_or_element) 
    226     classname = create_class_name(qname) 
     226    classname = mapped_class_basename(qname, @modulepath) 
    227227    check_classname(classname) 
    228228    c = ClassDef.new(classname, '::String') 
    …… 
    257257 
    258258  def create_classdef(qname, typedef, qualified = false) 
    259     classname = create_class_name(qname) 
     259    classname = mapped_class_basename(qname, @modulepath) 
    260260    check_classname(classname) 
    261261    baseclassname = nil 
    262262    if typedef.complexcontent 
    263263      if base = typedef.complexcontent.base 
    264         baseclassname = create_class_name(base) 
     264        baseclassname = mapped_class_basename(base, @modulepath) 
    265265      end 
    266266    end 
    …… 
    272272    c.comment = "#{qname}" 
    273273    c.comment << "\nabstract" if typedef.abstract 
     274    parentmodule = mapped_class_name(qname, @modulepath) 
    274275    init_lines, init_params = 
    275       parse_elements(c, typedef.elements, qname.namespace, classname) 
     276      parse_elements(c, typedef.elements, qname.namespace, parentmodule) 
    276277    unless typedef.attributes.empty? 
    277278      define_attribute(c, typedef.attributes) 
    …… 
    305306        typebase = @modulepath 
    306307        if element.anonymous_type? 
    307           inner = create_elementdef(element) 
     308          begin 
     309            # swap @modulepath: TODO be smarter 
     310            @modulepath = parentmodule 
     311            inner = create_elementdef(element) 
     312          ensure 
     313            @modulepath = typebase 
     314          end 
    308315          unless as_array 
    309316            inner.comment = "inner class for member: #{name}\n" + inner.comment 
    …… 
    380387 
    381388  def create_arraydef(qname, typedef) 
    382     classname = create_class_name(qname) 
     389    classname = mapped_class_basename(qname, @modulepath) 
    383390    check_classname(classname) 
    384391    c = ClassDef.new(classname, '::Array') 
    385392    c.comment = "#{qname}" 
    386     parse_elements(c, typedef.elements, qname.namespace, classname, true) 
     393    parentmodule = mapped_class_name(qname, @modulepath) 
     394    parse_elements(c, typedef.elements, qname.namespace, parentmodule, true) 
    387395    c 
    388396  end 

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

    r1939 r1948  
    2121  include XSD::CodeGen::GenSupport 
    2222 
    23   def create_class_name(qname, modulepath = nil) 
    24     @name_creator.create_name(qname, modulepath) 
     23  def mapped_class_name(qname, modulepath) 
     24    @name_creator.assign_name(qname, modulepath) 
     25  end 
     26 
     27  def mapped_class_basename(qname, modulepath) 
     28    name = @name_creator.assign_name(qname, modulepath) 
     29    name.sub(/\A.*:/, '') 
    2530  end 
    2631 
    …… 
    102107    elsif simpletype = @simpletypes[element.type] 
    103108      if simpletype.restriction and simpletype.restriction.enumeration? 
    104         create_class_name(element.type, modulepath) 
     109        mapped_class_name(element.type, modulepath) 
    105110      else 
    106111        nil 
    …… 
    109114      klass.name 
    110115    elsif element.type 
    111       create_class_name(element.type, modulepath) 
     116      mapped_class_name(element.type, modulepath) 
    112117    elsif element.ref 
    113       create_class_name(element.ref, modulepath) 
     118      mapped_class_name(element.ref, modulepath) 
    114119    elsif element.anonymous_type? 
    115120      # inner class 
    116       create_class_name(element.name, modulepath) 
     121      mapped_class_name(element.name, modulepath) 
    117122    else 
    118123      nil 

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

    r1941 r1948  
    2222  end 
    2323 
    24   def create_name(qname, modulepath = nil) 
     24  def assign_name(qname, modulepath = nil) 
     25    unless @classname[qname] 
     26      if klass = ::SOAP::TypeMap[qname] 
     27        name = ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
     28      else 
     29        name = safeconstname(qname.name) 
     30        if modulepath 
     31          name = [modulepath, name].join('::') 
     32        end 
     33        while @classname.value?(name) 
     34          name += '_' 
     35        end 
     36      end 
     37      @classname[qname] = name.freeze 
     38    end 
     39    return @classname[qname] 
     40=begin 
    2541    if klass = ::SOAP::TypeMap[qname] 
    2642      return ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
    …… 
    4056      name 
    4157    end 
     58=end 
    4259  end 
    4360end 

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

    r1939 r1948  
    5252 
    5353  def dump_porttype(porttype) 
    54     drv_name = create_class_name(porttype.name) 
     54    drv_name = mapped_class_basename(porttype.name, @modulepath) 
    5555 
    5656    result = "" 

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

    r1939 r1948  
    6161    drivername = porttype.name + @drivername_postfix 
    6262    qname = XSD::QName.new(porttype.namespace, drivername) 
    63     class_name = create_class_name(qname) 
     63    class_name = mapped_class_basename(qname, @modulepath) 
    6464    defined_const = {} 
    6565    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype) 

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

    r1939 r1948  
    8585    return <<__EOD__ 
    8686#{@varname}.set( 
    87   #{create_class_name(qname, @modulepath)}, 
     87  #{mapped_class_name(qname, @modulepath)}, 
    8888  ::SOAP::SOAPArray, 
    8989  ::SOAP::Mapping::EncodedRegistry::TypedArrayFactory, 

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

    r1939 r1948  
    132132  def dump_literal_array_typemap(qname, typedef) 
    133133    var = {} 
    134     var[:class] = create_class_name(qname, @modulepath) 
     134    var[:class] = mapped_class_name(qname, @modulepath) 
    135135    schema_ns = qname.namespace 
    136136    if typedef.name.nil? 
    …… 
    141141      var[:schema_type] = qname 
    142142    end 
    143     parentmodule = var[:class] 
    144     parsed_element = parse_elements(typedef.elements, qname.namespace, 
    145       parentmodule, nil) 
     143    parsed_element = 
     144      parse_elements(typedef.elements, qname.namespace, var[:class], nil) 
    146145    if parsed_element.empty? 
    147146      parsed_element = [create_soapenc_array_element_definition(typedef)] 
    …… 
    162161      else 
    163162        typename = child_element.type || child_element.name 
    164         type = create_class_name(typename, @modulepath) 
     163        type = mapped_class_name(typename, @modulepath) 
    165164      end 
    166165    elsif child_type 
    167       type = create_class_name(child_type, @modulepath) 
     166      type = mapped_class_name(child_type, @modulepath) 
    168167    else 
    169168      type = nil 

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

    r1941 r1948  
    2828  def dump_complex_typemap(qname, typedef, parentmodule, as_element = nil, qualified = nil) 
    2929    var = {} 
    30     var[:class] = create_class_name(qname, parentmodule) 
     30    var[:class] = mapped_class_name(qname, parentmodule) 
    3131    if as_element 
    3232      var[:schema_name] = as_element 
    …… 
    4545    end 
    4646    parentmodule = var[:class] 
    47     parsed_element = parse_elements(typedef.elements, qname.namespace, 
    48       parentmodule, qualified) 
     47    parsed_element = 
     48      parse_elements(typedef.elements, qname.namespace, parentmodule, qualified) 
    4949    if typedef.choice? 
    5050      parsed_element.unshift(:choice) 
    …… 
    6060  def dump_simple_typemap(qname, typedef, as_element = nil, qualified = nil) 
    6161    var = {} 
    62     var[:class] = create_class_name(qname, @modulepath) 
     62    var[:class] = mapped_class_name(qname, @modulepath) 
    6363    if as_element 
    6464      var[:schema_name] = as_element 
    …… 
    269269    end 
    270270    var = {} 
    271     var[:class] = create_class_name(qname, @modulepath) 
     271    var[:class] = mapped_class_name(qname, @modulepath) 
    272272    if as_element 
    273273      var[:schema_name] = as_element 

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

    r1939 r1948  
    9999      op_fault = {} 
    100100      soapfault = fault.soapfault 
    101       faultclass = create_class_name(fault.name, @modulepath) 
     101      faultclass = mapped_class_name(fault.name, @modulepath) 
    102102      op_fault[:ns] = fault.name.namespace 
    103103      op_fault[:name] = fault.name.name 
    …… 
    163163      case definedtype.compoundtype 
    164164      when :TYPE_STRUCT, :TYPE_EMPTY, :TYPE_ARRAY, :TYPE_SIMPLE 
    165         type = create_class_name(part.type, @modulepath) 
     165        type = mapped_class_name(part.type, @modulepath) 
    166166        [type, part.type.namespace, part.type.name] 
    167167      when :TYPE_MAP 

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

    r1939 r1948  
    5454 
    5555  def dump_porttype(name) 
    56     class_name = create_class_name(name) 
     56    class_name = mapped_class_basename(name, @modulepath) 
    5757    c = XSD::CodeGen::ClassDef.new(class_name) 
    5858    element_definitions = @definitions.collect_elements 

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

    r1939 r1948  
    4848 
    4949  def dump_porttype(porttype) 
    50     class_name = create_class_name(porttype.name, @modulepath) 
     50    class_name = mapped_class_name(porttype.name, @modulepath) 
    5151    defined_const = {} 
    5252    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name) 

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

    r1939 r1948  
    4949 
    5050  def dump_porttype(porttype) 
    51     class_name = create_class_name(porttype.name, @modulepath) 
     51    class_name = mapped_class_name(porttype.name, @modulepath) 
    5252    defined_const = {} 
    5353    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)