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

Changeset 1954

Show
Ignore:
Timestamp:
09/12/07 15:05:29 (8 months ago)
Author:
nahi
Message:
  • mapping_registry was not generated propery for anonymous complexTypes which have the same NCname. closes #355.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/lib/soap/generator.rb

    r1947 r1954  
    5555    @indent = '' 
    5656    @encode_char_regexp = 
    57       Regexp.new("[#{EncodeMap.keys.join}]", nil, XSD::Charset.encoding) 
     57      ENCODE_CHAR_REGEXP[XSD::Charset.encoding] ||= 
     58        Regexp.new("[#{EncodeMap.keys.join}]", nil, XSD::Charset.encoding) 
    5859 
    5960    prologue 
    …… 
    133134 
    134135  def encode_element(ns, obj, parent) 
    135     attrs = obj.extraattr.dup 
     136    attrs = obj.extraattr 
    136137    if obj.is_a?(SOAPBody) 
    137138      @reftarget = obj 
    …… 
    211212    @buf << str 
    212213  end 
     214 
     215  ENCODE_CHAR_REGEXP = {} 
    213216 
    214217  EncodeMap = { 
    …… 
    220223    "\r" => '&#xd;' 
    221224  } 
     225 
    222226  def encode_string(str) 
    223227    @buf << get_encoded(str) 

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

    r1953 r1954  
    9292    @elements.collect { |ele| 
    9393      next if @complextypes[ele.name] 
    94       c = create_elementdef(ele) 
     94      c = create_elementdef(@modulepath, ele) 
    9595      c ? c.dump : nil 
    9696    }.compact.join("\n") 
    …… 
    100100    @attributes.collect { |attribute| 
    101101      if attribute.local_simpletype 
    102         c = create_simpletypedef(attribute.name, attribute.local_simpletype) 
     102        c = create_simpletypedef(@modulepath, attribute.name, attribute.local_simpletype) 
    103103      end 
    104104      c ? c.dump : nil 
    …… 
    108108  def dump_simpletype 
    109109    @simpletypes.collect { |type| 
    110       c = create_simpletypedef(type.name, type) 
     110      c = create_simpletypedef(@modulepath, type.name, type) 
    111111      c ? c.dump : nil 
    112112    }.compact.join("\n") 
    …… 
    115115  def dump_complextype 
    116116    definitions = sort_dependency(@complextypes).collect { |type| 
    117       c = create_complextypedef(type.name, type) 
     117      c = create_complextypedef(@modulepath, type.name, type) 
    118118      c ? c.dump : nil 
    119119    }.compact.join("\n") 
    …… 
    126126  end 
    127127 
    128   def create_elementdef(ele) 
     128  def create_elementdef(mpath, ele) 
    129129    qualified = (ele.elementform == 'qualified') 
    130130    if ele.local_complextype 
    131       create_complextypedef(ele.name, ele.local_complextype, qualified) 
     131      create_complextypedef(mpath, ele.name, ele.local_complextype, qualified) 
    132132    elsif ele.local_simpletype 
    133       create_simpletypedef(ele.name, ele.local_simpletype, qualified) 
     133      create_simpletypedef(mpath, ele.name, ele.local_simpletype, qualified) 
    134134    elsif ele.empty? 
    135       create_simpleclassdef(ele.name, nil) 
     135      create_simpleclassdef(mpath, ele.name, nil) 
    136136    else 
    137137      # ignores type only element 
    …… 
    140140  end 
    141141 
    142   def create_simpletypedef(qname, simpletype, qualified = false) 
     142  def create_simpletypedef(mpath, qname, simpletype, qualified = false) 
    143143    if simpletype.restriction 
    144       create_simpletypedef_restriction(qname, simpletype, qualified) 
     144      create_simpletypedef_restriction(mpath, qname, simpletype, qualified) 
    145145    elsif simpletype.list 
    146       create_simpletypedef_list(qname, simpletype, qualified) 
     146      create_simpletypedef_list(mpath, qname, simpletype, qualified) 
    147147    elsif simpletype.union 
    148       create_simpletypedef_union(qname, simpletype, qualified) 
     148      create_simpletypedef_union(mpath, qname, simpletype, qualified) 
    149149    else 
    150150      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    152152  end 
    153153 
    154   def create_simpletypedef_restriction(qname, typedef, qualified) 
     154  def create_simpletypedef_restriction(mpath, qname, typedef, qualified) 
    155155    restriction = typedef.restriction 
    156156    unless restriction.enumeration? 
    …… 
    158158      return nil 
    159159    end 
    160     classname = mapped_class_basename(qname, @modulepath) 
     160    classname = mapped_class_basename(qname, mpath) 
    161161    c = ClassDef.new(classname, '::String') 
    162162    c.comment = "#{qname}" 
    …… 
    165165  end 
    166166 
    167   def create_simpletypedef_list(qname, typedef, qualified) 
     167  def create_simpletypedef_list(mpath, qname, typedef, qualified) 
    168168    list = typedef.list 
    169     classname = mapped_class_basename(qname, @modulepath) 
     169    classname = mapped_class_basename(qname, mpath) 
    170170    c = ClassDef.new(classname, '::Array') 
    171171    c.comment = "#{qname}" 
    …… 
    178178      c.comment << "\n  contains list of #{classname}::*" 
    179179    elsif list.itemtype 
    180       c.comment << "\n  contains list of #{mapped_class_basename(list.itemtype, @modulepath)}::*" 
     180      c.comment << "\n  contains list of #{mapped_class_basename(list.itemtype, mpath)}::*" 
    181181    else 
    182182      raise RuntimeError.new("unknown kind of list: #{list}") 
    …… 
    185185  end 
    186186 
    187   def create_simpletypedef_union(qname, typedef, qualified) 
     187  def create_simpletypedef_union(mpath, qname, typedef, qualified) 
    188188    union = typedef.union 
    189     classname = mapped_class_basename(qname, @modulepath) 
     189    classname = mapped_class_basename(qname, mpath) 
    190190    c = ClassDef.new(classname, '::String') 
    191191    c.comment = "#{qname}" 
    …… 
    221221  end 
    222222 
    223   def create_simpleclassdef(qname, type_or_element) 
    224     classname = mapped_class_basename(qname, @modulepath) 
     223  def create_simpleclassdef(mpath, qname, type_or_element) 
     224    classname = mapped_class_basename(qname, mpath) 
    225225    c = ClassDef.new(classname, '::String') 
    226226    c.comment = "#{qname}" 
    …… 
    236236  end 
    237237 
    238   def create_complextypedef(qname, type, qualified = false) 
     238  def create_complextypedef(mpath, qname, type, qualified = false) 
    239239    case type.compoundtype 
    240240    when :TYPE_STRUCT, :TYPE_EMPTY 
    241       create_classdef(qname, type, qualified) 
     241      create_classdef(mpath, qname, type, qualified) 
    242242    when :TYPE_ARRAY 
    243       create_arraydef(qname, type) 
     243      create_arraydef(mpath, qname, type) 
    244244    when :TYPE_SIMPLE 
    245       create_simpleclassdef(qname, type) 
     245      create_simpleclassdef(mpath, qname, type) 
    246246    when :TYPE_MAP 
    247247      # mapped as a general Hash 
    …… 
    253253  end 
    254254 
    255   def create_classdef(qname, typedef, qualified = false) 
    256     classname = mapped_class_basename(qname, @modulepath) 
     255  def create_classdef(mpath, qname, typedef, qualified = false) 
     256    classname = mapped_class_basename(qname, mpath) 
    257257    baseclassname = nil 
    258258    if typedef.complexcontent 
    259259      if base = typedef.complexcontent.base 
    260         baseclassname = mapped_class_basename(base, @modulepath) 
     260        baseclassname = mapped_class_basename(base, mpath) 
    261261      end 
    262262    end 
    …… 
    268268    c.comment = "#{qname}" 
    269269    c.comment << "\nabstract" if typedef.abstract 
    270     parentmodule = mapped_class_name(qname, @modulepath) 
     270    parentmodule = mapped_class_name(qname, mpath) 
    271271    init_lines, init_params = 
    272272      parse_elements(c, typedef.elements, qname.namespace, parentmodule) 
    …… 
    281281  end 
    282282 
    283   def parse_elements(c, elements, base_namespace, parentmodule, as_array = false) 
     283  def parse_elements(c, elements, base_namespace, mpath, as_array = false) 
    284284    init_lines = [] 
    285285    init_params = [] 
    …… 
    302302        typebase = @modulepath 
    303303        if element.anonymous_type? 
    304           begin 
    305             # swap @modulepath: TODO be smarter 
    306             @modulepath = parentmodule 
    307             inner = create_elementdef(element) 
    308           ensure 
    309             @modulepath = typebase 
    310           end 
     304          inner = create_elementdef(mpath, element) 
    311305          unless as_array 
    312306            inner.comment = "inner class for member: #{name}\n" + inner.comment 
    313307          end 
    314308          c.innermodule << inner 
    315           typebase = parentmodule 
     309          typebase = mpath 
    316310        end 
    317311        unless as_array 
    …… 
    325319            init_params << "#{varname} = nil" 
    326320          end 
    327           c.comment << "\n  #{attrname} - #{create_type_name(element, typebase) || '(any)'}" 
     321          c.comment << "\n  #{attrname} - #{create_type_name(typebase, element) || '(any)'}" 
    328322        end 
    329323      when WSDL::XMLSchema::Sequence 
    330324        child_init_lines, child_init_params = 
    331           parse_elements(c, element.elements, base_namespace, parentmodule, as_array) 
     325          parse_elements(c, element.elements, base_namespace, mpath, as_array) 
    332326        init_lines.concat(child_init_lines) 
    333327        init_params.concat(child_init_params) 
    334328      when WSDL::XMLSchema::Choice 
    335329        child_init_lines, child_init_params = 
    336           parse_elements(c, element.elements, base_namespace, parentmodule, as_array) 
     330          parse_elements(c, element.elements, base_namespace, mpath, as_array) 
    337331        init_lines.concat(child_init_lines) 
    338332        init_params.concat(child_init_params) 
    …… 
    343337        end 
    344338        child_init_lines, child_init_params = 
    345           parse_elements(c, element.content.elements, base_namespace, parentmodule, as_array) 
     339          parse_elements(c, element.content.elements, base_namespace, mpath, as_array) 
    346340        init_lines.concat(child_init_lines) 
    347341        init_params.concat(child_init_params) 
    …… 
    382376  end 
    383377 
    384   def create_arraydef(qname, typedef) 
    385     classname = mapped_class_basename(qname, @modulepath) 
     378  def create_arraydef(mpath, qname, typedef) 
     379    classname = mapped_class_basename(qname, mpath) 
    386380    c = ClassDef.new(classname, '::Array') 
    387381    c.comment = "#{qname}" 
    388     parentmodule = mapped_class_name(qname, @modulepath) 
     382    parentmodule = mapped_class_name(qname, mpath) 
    389383    parse_elements(c, typedef.elements, qname.namespace, parentmodule, true) 
    390384    c 

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

    r1953 r1954  
    1717 
    1818 
    19 # requires @defined_const, @simpletypes, @name_creator, and @modulepath 
     19# requires @defined_const, @simpletypes, @name_creator 
    2020module ClassDefCreatorSupport 
    2121  include XSD::CodeGen::GenSupport 
    …… 
    101101  end 
    102102 
    103   def create_type_name(element, modulepath = @modulepath) 
     103  def create_type_name(modulepath, element) 
    104104    if element.type == XSD::AnyTypeName 
    105105      # nil means anyType. 

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

    r1953 r1954  
    2323 
    2424  def assign_name(qname, modulepath = nil) 
    25     unless @classname[qname] 
     25    key = [modulepath, qname] 
     26    unless @classname.key?(key) 
    2627      if klass = ::SOAP::TypeMap[qname] 
    27         name = ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
     28        name = 
     29          ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
    2830      else 
    2931        name = safeconstname(qname.name) 
    …… 
    3638        check_classname(name) 
    3739      end 
    38       @classname[qname] = name.freeze 
     40      @classname[key] = name.freeze 
    3941    end 
    40     return @classname[qname] 
    41 =begin 
    42     if klass = ::SOAP::TypeMap[qname] 
    43       return ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name 
    44     end 
    45     if @classname.key?(qname) 
    46       name = @classname[qname] 
    47     else 
    48       name = safeconstname(qname.name) 
    49       while @classname.value?(name) 
    50         name += '_' 
    51       end 
    52       @classname[qname] = name.freeze 
    53     end 
    54     if modulepath 
    55       [modulepath, name].join('::') 
    56     else 
    57       name 
    58     end 
    59 =end 
     42    @classname[key] 
    6043  end 
    6144 

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

    r1948 r1954  
    5252  def dump_complextype 
    5353    @complextypes.collect { |type| 
    54       dump_complextypedef(type.name, type) unless type.abstract 
     54      dump_complextypedef(@modulepath, type.name, type) unless type.abstract 
    5555    }.compact.join("\n") 
    5656  end 
    …… 
    5858  def dump_simpletype 
    5959    @simpletypes.collect { |type| 
    60       dump_simpletypedef(type.name, type) 
     60      dump_simpletypedef(@modulepath, type.name, type) 
    6161    }.compact.join("\n") 
    6262  end 
    6363 
    64   def dump_complextypedef(qname, typedef) 
     64  def dump_complextypedef(mpath, qname, typedef) 
    6565    case typedef.compoundtype 
    6666    when :TYPE_STRUCT, :TYPE_EMPTY 
    67       dump_struct_typemap(qname, typedef) 
     67      dump_struct_typemap(mpath, qname, typedef) 
    6868    when :TYPE_ARRAY 
    69       dump_encoded_array_typemap(qname, typedef) 
     69      dump_encoded_array_typemap(mpath, qname, typedef) 
    7070    when :TYPE_SIMPLE 
    71       dump_simple_typemap(qname, typedef) 
     71      dump_simple_typemap(mpath, qname, typedef) 
    7272    when :TYPE_MAP 
    7373      # mapped as a general Hash 
    …… 
    7979  end 
    8080 
    81   def dump_encoded_array_typemap(qname, typedef) 
     81  def dump_encoded_array_typemap(mpath, qname, typedef) 
    8282    arytype = typedef.find_arytype || XSD::AnyTypeName 
    8383    type = XSD::QName.new(arytype.namespace, arytype.name.sub(/\[(?:,)*\]$/, '')) 
    …… 
    8585    return <<__EOD__ 
    8686#{@varname}.set( 
    87   #{mapped_class_name(qname, @modulepath)}, 
     87  #{mapped_class_name(qname, mpath)}, 
    8888  ::SOAP::SOAPArray, 
    8989  ::SOAP::Mapping::EncodedRegistry::TypedArrayFactory, 

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

    r1948 r1954  
    6767      qualified = (ele.elementform == 'qualified') 
    6868      if ele.local_complextype 
    69         dump_complextypedef(ele.name, ele.local_complextype, nil, qualified) 
     69        dump_complextypedef(@modulepath, ele.name, ele.local_complextype, nil, qualified) 
    7070      elsif ele.local_simpletype 
    71         dump_simpletypedef(ele.name, ele.local_simpletype, nil, qualified) 
     71        dump_simpletypedef(@modulepath, ele.name, ele.local_simpletype, nil, qualified) 
    7272      elsif ele.type 
    7373        if typedef = @complextypes[ele.type] 
    74           dump_complextypedef(ele.type, typedef, ele.name, qualified) 
     74          dump_complextypedef(@modulepath, ele.type, typedef, ele.name, qualified) 
    7575        elsif typedef = @simpletypes[ele.type] 
    76           dump_simpletypedef(ele.type, typedef, ele.name, qualified) 
     76          dump_simpletypedef(@modulepath, ele.type, typedef, ele.name, qualified) 
    7777        else 
    7878          nil 
    …… 
    8787    @attributes.collect { |attr| 
    8888      if attr.local_simpletype 
    89         dump_simpletypedef(attr.name, attr.local_simpletype) 
     89        dump_simpletypedef(@modulepath, attr.name, attr.local_simpletype) 
    9090      end 
    9191    }.compact.join("\n") 
    …… 
    9494  def dump_simpletype 
    9595    @simpletypes.collect { |type| 
    96       dump_simpletypedef(type.name, type) 
     96      dump_simpletypedef(@modulepath, type.name, type) 
    9797    }.compact.join("\n") 
    9898  end 
    …… 
    100100  def dump_complextype 
    101101    @complextypes.collect { |type| 
    102       dump_complextypedef(type.name, type) unless type.abstract 
     102      dump_complextypedef(@modulepath, type.name, type) unless type.abstract 
    103103    }.compact.join("\n") 
    104104  end 
    105105 
    106   def dump_complextypedef(qname, typedef, as_element = nil, qualified = false) 
     106  def dump_complextypedef(mpath, qname, typedef, as_element = nil, qualified = false) 
    107107    case typedef.compoundtype 
    108108    when :TYPE_STRUCT, :TYPE_EMPTY 
    109       dump_struct_typemap(qname, typedef, as_element, qualified) 
     109      dump_struct_typemap(mpath, qname, typedef, as_element, qualified) 
    110110    when :TYPE_ARRAY 
    111       dump_array_typemap(qname, typedef) 
     111      dump_array_typemap(mpath, qname, typedef) 
    112112    when :TYPE_SIMPLE 
    113       dump_simple_typemap(qname, typedef, as_element, qualified) 
     113      dump_simple_typemap(mpath, qname, typedef, as_element, qualified) 
    114114    when :TYPE_MAP 
    115115      # mapped as a general Hash 
    …… 
    123123  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item') 
    124124 
    125   def dump_array_typemap(qname, typedef) 
     125  def dump_array_typemap(mpath, qname, typedef) 
    126126    @dump_struct_typemap_innerstruct = [] 
    127127    @dump_struct_typemap_innerstruct.unshift( 
    128       dump_literal_array_typemap(qname, typedef)) 
     128      dump_literal_array_typemap(mpath, qname, typedef)) 
    129129    @dump_struct_typemap_innerstruct.join("\n") 
    130130  end 
    131131 
    132   def dump_literal_array_typemap(qname, typedef) 
     132  def dump_literal_array_typemap(mpath, qname, typedef) 
    133133    var = {} 
    134     var[:class] = mapped_class_name(qname, @modulepath) 
     134    var[:class] = mapped_class_name(qname, mpath) 
    135135    schema_ns = qname.namespace 
    136136    if typedef.name.nil? 
    …… 
    144144      parse_elements(typedef.elements, qname.namespace, var[:class], nil) 
    145145    if parsed_element.empty? 
    146       parsed_element = [create_soapenc_array_element_definition(typedef)] 
     146      parsed_element = [create_soapenc_array_element_definition(typedef, mpath)] 
    147147    end 
    148148    var[:schema_element] = dump_schema_element_definition(parsed_element, 2) 
    …… 
    151151  end 
    152152 
    153   def create_soapenc_array_element_definition(typedef) 
     153  def create_soapenc_array_element_definition(typedef, mpath) 
    154154    child_type = typedef.child_type 
    155155    child_element = typedef.find_aryelement 
    …… 
    161161      else 
    162162        typename = child_element.type || child_element.name 
    163         type = mapped_class_name(typename, @modulepath) 
     163        type = mapped_class_name(typename, mpath) 
    164164      end 
    165165    elsif child_type 
    166       type = mapped_class_name(child_type, @modulepath) 
     166      type = mapped_class_name(child_type, mpath) 
    167167    else 
    168168      type = nil 

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

    r1948 r1954  
    1414 
    1515 
    16 # requires @defined_const = {}, @dump_struct_typemap_innerstruct 
     16# requires @defined_const = {}, @dump_struct_typemap_innerstruct, @modulepath 
    1717module MappingRegistryCreatorSupport 
    1818  include ClassDefCreatorSupport 
    1919  include XSD::CodeGen 
    2020 
    21   def dump_struct_typemap(qname, typedef, as_element = nil, qualified = nil) 
     21  def dump_struct_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
    2222    @dump_struct_typemap_innerstruct = [] 
    2323    @dump_struct_typemap_innerstruct.unshift( 
    24       dump_complex_typemap(qname, typedef, @modulepath, as_element, qualified)) 
     24      dump_complex_typemap(mpath, qname, typedef, as_element, qualified)) 
    2525    @dump_struct_typemap_innerstruct.join("\n") 
    2626  end 
    2727 
    28   def dump_complex_typemap(qname, typedef, parentmodule, as_element = nil, qualified = nil) 
     28  def dump_complex_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
    2929    var = {} 
    30     var[:class] = mapped_class_name(qname, parentmodule) 
     30    var[:class] = mapped_class_name(qname, mpath) 
    3131    if as_element 
    3232      var[:schema_name] = as_element 
    …… 
    5858  end 
    5959 
    60   def dump_simple_typemap(qname, typedef, as_element = nil, qualified = nil) 
     60  def dump_simple_typemap(mpath, qname, typedef, as_element = nil, qualified = nil) 
    6161    var = {} 
    62     var[:class] = mapped_class_name(qname, @modulepath) 
     62    var[:class] = mapped_class_name(qname, mpath) 
    6363    if as_element 
    6464      var[:schema_name] = as_element 
    …… 
    123123  end 
    124124 
    125   def parse_elements(elements, base_namespace, parentmodule, qualified = false) 
     125  def parse_elements(elements, base_namespace, mpath, qualified = false) 
    126126    schema_element = [] 
    127127    any = false 
    …… 
    141141        typebase = @modulepath 
    142142        if element.anonymous_type? 
    143           @dump_struct_typemap_innerstruct << 
    144             dump_complex_typemap(element.name, element.local_complextype, 
    145               parentmodule, nil, qualified) 
    146           typebase = parentmodule 
    147         end 
    148         type = create_type_name(element, typebase) 
     143          @dump_struct_typemap_innerstruct << dump_complex_typemap( 
     144              mpath, element.name, element.local_complextype, nil, qualified) 
     145          typebase = mpath 
     146        end 
     147        type = create_type_name(typebase, element) 
    149148        name = name_element(element).name 
    150149        varname = safevarname(name) 
    …… 
    165164      when WSDL::XMLSchema::Sequence 
    166165        child_schema_element = 
    167           parse_elements(element.elements, base_namespace, parentmodule, qualified) 
     166          parse_elements(element.elements, base_namespace, mpath, qualified) 
    168167        schema_element << child_schema_element 
    169168      when WSDL::XMLSchema::Choice 
    170169        child_schema_element = 
    171           parse_elements(element.elements, base_namespace, parentmodule, qualified) 
     170          parse_elements(element.elements, base_namespace, mpath, qualified) 
    172171        if !element.map_as_array? 
    173172          # choice + maxOccurs="unbounded" is treated just as 'all' now. 
    …… 
    181180        end 
    182181        child_schema_element = 
    183           parse_elements(element.content.elements, base_namespace, parentmodule, qualified) 
     182          parse_elements(element.content.elements, base_namespace, mpath, qualified) 
    184183        schema_element.concat(child_schema_element) 
    185184      else 
    …… 
    250249  end 
    251250 
    252   def dump_simpletypedef(qname, simpletype, as_element = nil, qualified = false) 
     251  def dump_simpletypedef(mpath, qname, simpletype, as_element = nil, qualified = false) 
    253252    if simpletype.restriction 
    254       dump_simpletypedef_restriction(qname, simpletype, as_element, qualified) 
     253      dump_simpletypedef_restriction(mpath, qname, simpletype, as_element, qualified) 
    255254    elsif simpletype.list 
    256       dump_simpletypedef_list(qname, simpletype, as_element, qualified) 
     255      dump_simpletypedef_list(mpath, qname, simpletype, as_element, qualified) 
    257256    elsif simpletype.union 
    258       dump_simpletypedef_union(qname, simpletype, as_element, qualified) 
     257      dump_simpletypedef_union(mpath, qname, simpletype, as_element, qualified) 
    259258    else 
    260259      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    262261  end 
    263262 
    264   def dump_simpletypedef_restriction(qname, typedef, as_element, qualified) 
     263  def dump_simpletypedef_restriction(mpath, qname, typedef, as_element, qualified) 
    265264    restriction = typedef.restriction 
    266265    unless restriction.enumeration? 
    …… 
    269268    end 
    270269    var = {} 
    271     var[:class] = mapped_class_name(qname, @modulepath) 
     270    var[:class] = mapped_class_name(qname, mpath) 
    272271    if as_element 
    273272      var[:schema_name] = as_element 
    …… 
    284283  end 
    285284 
    286   def dump_simpletypedef_list(qname, typedef, as_element, qualified) 
     285  def dump_simpletypedef_list(mpath, qname, typedef, as_element, qualified) 
    287286    nil 
    288287  end 
    289288 
    290   def dump_simpletypedef_union(qname, typedef, as_element, qualified) 
     289  def dump_simpletypedef_union(mpath, qname, typedef, as_element, qualified) 
    291290    nil 
    292291  end 

  • trunk/test/soap/test_custom_ns.rb

    r1898 r1954  
    2727<?xml version="1.0" encoding="utf-8" ?> 
    2828<ENV:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
     29    xmlns:myns="my:foo" 
    2930    xmlns:ENV="http://schemas.xmlsoap.org/soap/envelope/" 
    30     xmlns:myns="my:foo" 
    3131    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> 
    3232  <ENV:Header> 
    …… 
    5555    assert_equal(NORMAL_XML, result) 
    5656    # Envelope ns customize 
     57    env = SOAP::SOAPEnvelope.new(header, body) 
    5758    ns = XSD::NS.new 
    5859    ns.assign(SOAP::EnvelopeNamespace, 'ENV') 

  • trunk/test/wsdl/anonymous/expectedClassDef.rb

    r1949 r1954  
    33module WSDL; module Anonymous 
    44 
     5 
     6# {urn:lp}Header 
     7#   header3 - SOAP::SOAPString 
     8class Header 
     9  attr_accessor :header3 
     10 
     11  def initialize(header3 = nil) 
     12    @header3 = header3 
     13  end 
     14end 
    515 
    616# {urn:lp}ExtraInfo 
    …… 
    4353end 
    4454 
     55# {urn:lp}Pack 
     56#   header - WSDL::Anonymous::Pack::Header 
     57class Pack 
     58 
     59  # inner class for member: Header 
     60  # {}Header 
     61  #   header1 - SOAP::SOAPString 
     62  class Header 
     63    attr_accessor :header1 
     64 
     65    def initialize(header1 = nil) 
     66      @header1 = header1 
     67    end 
     68  end 
     69 
     70  attr_accessor :header 
     71 
     72  def initialize(header = nil) 
     73    @header = header 
     74  end 
     75end 
     76 
     77# {urn:lp}Envelope 
     78#   header - WSDL::Anonymous::Envelope::Header 
     79class Envelope 
     80 
     81  # inner class for member: Header 
     82  # {}Header 
     83  #   header2 - SOAP::SOAPString 
     84  class Header 
     85    attr_accessor :header2 
     86 
     87    def initialize(header2 = nil) 
     88      @header2 = header2 
     89    end 
     90  end 
     91 
     92  attr_accessor :header 
     93 
     94  def initialize(header = nil) 
     95    @header = header 
     96  end 
     97end 
     98 
    4599# {urn:lp}login 
    46100#   loginRequest - WSDL::Anonymous::Login::LoginRequest 

  • trunk/test/wsdl/anonymous/expectedMappingRegistry.rb

    r1938 r1954  
    99  NsLp = "urn:lp" 
    1010  NsXMLSchema = "http://www.w3.org/2001/XMLSchema" 
     11 
     12  EncodedRegistry.register( 
     13    :class => WSDL::Anonymous::Header, 
     14    :schema_type => XSD::QName.new(NsLp, "Header"), 
     15    :schema_element => [ 
     16      ["header3", ["SOAP::SOAPString", XSD::QName.new(nil, "Header3")]] 
     17    ] 
     18  ) 
    1119 
    1220  EncodedRegistry.set( 
    …… 
    3038    :schema_element => [ 
    3139      ["sessionID", "SOAP::SOAPString"] 
     40    ] 
     41  ) 
     42 
     43  LiteralRegistry.register( 
     44    :class => WSDL::Anonymous::Header, 
     45    :schema_type => XSD::QName.new(NsLp, "Header"), 
     46    :schema_qualified => false, 
     47    :schema_element => [ 
     48      ["header3", ["SOAP::SOAPString", XSD::QName.new(nil, "Header3")]] 
    3249    ] 
    3350  ) 
    …… 
    6986 
    7087  LiteralRegistry.register( 
     88    :class => WSDL::Anonymous::Pack, 
     89    :schema_name => XSD::QName.new(NsLp, "Pack"), 
     90    :schema_qualified => true, 
     91    :schema_element => [ 
     92      ["header", ["WSDL::Anonymous::Pack::Header", XSD::QName.new(nil, "Header")]] 
     93    ] 
     94  ) 
     95 
     96  LiteralRegistry.register( 
     97    :class => WSDL::Anonymous::Pack::Header, 
     98    :schema_name => XSD::QName.new(nil, "Header"), 
     99    :schema_qualified => true, 
     100    :schema_element => [ 
     101      ["header1", ["SOAP::SOAPString", XSD::QName.new(nil, "Header1")]] 
     102    ] 
     103  ) 
     104 
     105  LiteralRegistry.register( 
     106    :class => WSDL::Anonymous::Envelope, 
     107    :schema_name => XSD::QName.new(NsLp, "Envelope"), 
     108    :schema_qualified => true, 
     109    :schema_element => [ 
     110      ["header", ["WSDL::Anonymous::Envelope::Header", XSD::QName.new(nil, "Header")]] 
     111    ] 
     112  ) 
     113 
     114  LiteralRegistry.register( 
     115    :class => WSDL::Anonymous::Envelope::Header, 
     116    :schema_name => XSD::QName.new(nil, "Header"), 
     117    :schema_qualified => true, 
     118    :schema_element => [ 
     119      ["header2", ["SOAP::SOAPString", XSD::QName.new(nil, "Header2")]] 
     120    ] 
     121  ) 
     122 
     123  LiteralRegistry.register( 
    71124    :class => WSDL::Anonymous::Login, 
    72125    :schema_name => XSD::QName.new(NsLp, "login"), 

  • trunk/test/wsdl/anonymous/lp.wsdl

    r1934 r1954  
    99  <types> 
    1010    <schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="urn:lp"> 
     11      <element name="Pack"> 
     12        <complexType> 
     13          <sequence> 
     14            <element name="Header"> 
     15              <complexType> 
     16                <sequence> 
     17                  <element name="Header1" type="xsd:string"/> 
     18                </sequence> 
     19              </complexType> 
     20            </element> 
     21          </sequence> 
     22        </complexType> 
     23      </element> 
     24 
     25      <element name="Envelope"> 
     26        <complexType> 
     27          <sequence> 
     28            <element name="Header"> 
     29              <complexType> 
     30                <sequence> 
     31                  <element name="Header2" type="xsd:string"/> 
     32                </sequence> 
     33              </complexType> 
     34            </element> 
     35          </sequence> 
     36        </complexType> 
     37      </element> 
     38 
     39      <complexType name="Header"> 
     40        <sequence> 
     41          <element name="Header3" type="xsd:string"/> 
     42        </sequence> 
     43      </complexType> 
     44 
    1145      <complexType name="ExtraInfo"> 
    1246        <annotation>