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

Changeset 1944

Show
Ignore:
Timestamp:
09/08/07 23:42:12 (8 months ago)
Author:
nahi
Message:
  • incomplete anonymous complexType support (simpleContent wrongly mapped to a generic class). closes #355.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

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

    r1939 r1944  
    9292    @elements.collect { |ele| 
    9393      next if @complextypes[ele.name] 
    94       qualified = (ele.elementform == 'qualified') 
    95       if ele.local_complextype 
    96         dump_complextypedef(ele.name, ele.local_complextype, qualified) 
    97       elsif ele.local_simpletype 
    98         dump_simpletypedef(ele.name, ele.local_simpletype, qualified) 
    99       elsif ele.empty? 
    100         dump_simpleclassdef(ele.name, nil) 
    101       else 
    102         # ignores type only element 
    103         nil 
    104       end 
     94      c = create_elementdef(ele) 
     95      c ? c.dump : nil 
    10596    }.compact.join("\n") 
    10697  end 
    10798 
    10899  def dump_attribute 
    109     @attributes.collect { |attr| 
    110       if attr.local_simpletype 
    111         dump_simpletypedef(attr.name, attr.local_simpletype) 
    112       end 
     100    @attributes.collect { |attribute| 
     101      if attribute.local_simpletype 
     102        c = create_simpletypedef(attribute.name, attribute.local_simpletype) 
     103      end 
     104      c ? c.dump : nil 
    113105    }.compact.join("\n") 
    114106  end 
    …… 
    116108  def dump_simpletype 
    117109    @simpletypes.collect { |type| 
    118       dump_simpletypedef(type.name, type) 
     110      c = create_simpletypedef(type.name, type) 
     111      c ? c.dump : nil 
    119112    }.compact.join("\n") 
    120113  end 
    …… 
    122115  def dump_complextype 
    123116    definitions = sort_dependency(@complextypes).collect { |type| 
    124       dump_complextypedef(type.name, type) 
     117      c = create_complextypedef(type.name, type) 
     118      c ? c.dump : nil 
    125119    }.compact.join("\n") 
    126120  end 
    …… 
    128122  def dump_group 
    129123    definitions = @modelgroups.collect { |group| 
    130       # ??? 
     124      # TODO: not dumped for now but may be useful in the future 
    131125    }.compact.join("\n") 
    132126  end 
    133127 
    134   def dump_simpletypedef(qname, simpletype, qualified = false) 
     128  def create_elementdef(ele) 
     129    qualified = (ele.elementform == 'qualified') 
     130    if ele.local_complextype 
     131      create_complextypedef(ele.name, ele.local_complextype, qualified) 
     132    elsif ele.local_simpletype 
     133      create_simpletypedef(ele.name, ele.local_simpletype, qualified) 
     134    elsif ele.empty? 
     135      create_simpleclassdef(ele.name, nil) 
     136    else 
     137      # ignores type only element 
     138      nil 
     139    end 
     140  end 
     141 
     142  def create_simpletypedef(qname, simpletype, qualified = false) 
    135143    if simpletype.restriction 
    136       dump_simpletypedef_restriction(qname, simpletype, qualified) 
     144      create_simpletypedef_restriction(qname, simpletype, qualified) 
    137145    elsif simpletype.list 
    138       dump_simpletypedef_list(qname, simpletype, qualified) 
     146      create_simpletypedef_list(qname, simpletype, qualified) 
    139147    elsif simpletype.union 
    140       dump_simpletypedef_union(qname, simpletype, qualified) 
     148      create_simpletypedef_union(qname, simpletype, qualified) 
    141149    else 
    142150      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}") 
    …… 
    144152  end 
    145153 
    146   def dump_simpletypedef_restriction(qname, typedef, qualified) 
     154  def create_simpletypedef_restriction(qname, typedef, qualified) 
    147155    restriction = typedef.restriction 
    148156    unless restriction.enumeration? 
    …… 
    155163    c.comment = "#{qname}" 
    156164    define_classenum_restriction(c, classname, restriction.enumeration) 
    157     c.dump 
    158   end 
    159  
    160   def dump_simpletypedef_list(qname, typedef, qualified) 
     165    c 
     166  end 
     167 
     168  def create_simpletypedef_list(qname, typedef, qualified) 
    161169    list = typedef.list 
    162170    classname = create_class_name(qname) 
    …… 
    176184      raise RuntimeError.new("unknown kind of list: #{list}") 
    177185    end 
    178     c.dump 
    179   end 
    180  
    181   def dump_simpletypedef_union(qname, typedef, qualified) 
     186    c 
     187  end 
     188 
     189  def create_simpletypedef_union(qname, typedef, qualified) 
    182190    union = typedef.union 
    183191    classname = create_class_name(qname) 
    …… 
    188196      c.comment << "\n any of #{union.member_types}" 
    189197    end 
    190     c.dump 
     198    c 
    191199  end 
    192200 
    …… 
    215223  end 
    216224 
    217   def dump_simpleclassdef(qname, type_or_element) 
     225  def create_simpleclassdef(qname, type_or_element) 
    218226    classname = create_class_name(qname) 
    219227    check_classname(classname) 
    …… 
    228236      "super\n" + init_lines.join("\n") 
    229237    end 
    230     c.dump 
    231   end 
    232  
    233   def dump_complextypedef(qname, type, qualified = false) 
     238    c 
     239  end 
     240 
     241  def create_complextypedef(qname, type, qualified = false) 
    234242    case type.compoundtype 
    235243    when :TYPE_STRUCT, :TYPE_EMPTY 
    236       dump_classdef(qname, type, qualified) 
     244      create_classdef(qname, type, qualified) 
    237245    when :TYPE_ARRAY 
    238       dump_arraydef(qname, type) 
     246      create_arraydef(qname, type) 
    239247    when :TYPE_SIMPLE 
    240       dump_simpleclassdef(qname, type) 
     248      create_simpleclassdef(qname, type) 
    241249    when :TYPE_MAP 
    242250      # mapped as a general Hash 
    …… 
    246254        "unknown kind of complexContent: #{type.compoundtype}") 
    247255    end 
    248   end 
    249  
    250   def dump_classdef(qname, typedef, qualified = false) 
    251     create_classdef(qname, typedef, qualified).dump 
    252256  end 
    253257 
    …… 
    301305        typebase = @modulepath 
    302306        if element.anonymous_type? 
    303           inner = create_classdef(element.name, element.local_complextype) 
     307          inner = create_elementdef(element) 
    304308          unless as_array 
    305309            inner.comment = "inner class for member: #{name}\n" + inner.comment 
    …… 
    375379  end 
    376380 
    377   def dump_arraydef(qname, typedef) 
     381  def create_arraydef(qname, typedef) 
    378382    classname = create_class_name(qname) 
    379383    check_classname(classname) 
    …… 
    381385    c.comment = "#{qname}" 
    382386    parse_elements(c, typedef.elements, qname.namespace, classname, true) 
    383     c.dump 
     387    c 
    384388  end 
    385389 

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

    r1934 r1944  
    147147  # {}Comment_1 
    148148  #   xmlattr_msgid - SOAP::SOAPString 
    149   class Comment_1 
     149  class Comment_1 < ::String 
    150150    AttrMsgid = XSD::QName.new(nil, "msgid") 
    151151 
    …… 
    162162    end 
    163163 
    164     def initialize 
     164    def initialize(*arg) 
     165      super 
    165166      @__xmlattr = {} 
    166167    end