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

Changeset 1915

Show
Ignore:
Timestamp:
08/05/07 23:25:19 (10 months ago)
Author:
nahi
Message:
  • added support for anonymous type. anonymous type is mapped to inner class. closes #355.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/lib/wsdl/soap/classDefCreator.rb

    r1914 r1915  
    245245 
    246246  def dump_classdef(qname, typedef, qualified = false) 
     247    create_classdef(qname, typedef, qualified).dump 
     248  end 
     249 
     250  def create_classdef(qname, typedef, qualified = false) 
    247251    classname = create_class_name(qname) 
    248252    check_classname(classname) 
     
    261265    c.comment << "\nabstract" if typedef.abstract 
    262266    init_lines, init_params = 
    263       parse_elements(c, typedef.elements, qname.namespace
     267      parse_elements(c, typedef.elements, qname.namespace, classname
    264268    unless typedef.attributes.empty? 
    265269      define_attribute(c, typedef.attributes) 
     
    269273      init_lines.join("\n") 
    270274    end 
    271     c.dump 
    272   end 
    273  
    274   def parse_elements(c, elements, base_namespace
     275    c 
     276  end 
     277 
     278  def parse_elements(c, elements, base_namespace, parentmodule
    275279    init_lines = [] 
    276280    init_params = [] 
     
    291295        next if element.ref == SchemaName 
    292296        name = name_element(element).name 
     297        typebase = @modulepath 
     298        if element.anonymous_type? 
     299          inner = create_classdef(element.name, element.local_complextype) 
     300          inner.comment = "inner class for member: #{name}\n" + inner.comment 
     301          c.innermodule << inner 
     302          typebase = parentmodule 
     303        end 
    293304        attrname = safemethodname(name) 
    294305        varname = safevarname(name) 
     
    300311          init_params << "#{varname} = nil" 
    301312        end 
    302         c.comment << "\n  #{attrname} - #{create_type_name(element) || '(any)'}" 
     313        c.comment << "\n  #{attrname} - #{create_type_name(element, typebase) || '(any)'}" 
    303314      when WSDL::XMLSchema::Sequence 
    304315        child_init_lines, child_init_params = 
    305           parse_elements(c, element.elements, base_namespace
     316          parse_elements(c, element.elements, base_namespace, parentmodule
    306317        init_lines.concat(child_init_lines) 
    307318        init_params.concat(child_init_params) 
    308319      when WSDL::XMLSchema::Choice 
    309320        child_init_lines, child_init_params = 
    310           parse_elements(c, element.elements, base_namespace
     321          parse_elements(c, element.elements, base_namespace, parentmodule
    311322        init_lines.concat(child_init_lines) 
    312323        init_params.concat(child_init_params) 
     
    317328        end 
    318329        child_init_lines, child_init_params = 
    319           parse_elements(c, element.content.elements, base_namespace
     330          parse_elements(c, element.content.elements, base_namespace, parentmodule
    320331        init_lines.concat(child_init_lines) 
    321332        init_params.concat(child_init_params) 
  • trunk/lib/wsdl/soap/classDefCreatorSupport.rb

    r1914 r1915  
    105105  end 
    106106 
    107   def create_type_name(element
     107  def create_type_name(element, modulepath = @modulepath
    108108    if element.type == XSD::AnyTypeName 
     109      # nil means anyType. 
    109110      nil 
    110111    elsif simpletype = @simpletypes[element.type] 
    111112      if simpletype.restriction and simpletype.restriction.enumeration? 
    112         create_class_name(element.type, @modulepath) 
     113        create_class_name(element.type, modulepath) 
    113114      else 
    114115        nil 
     
    117118      klass.name 
    118119    elsif element.type 
    119       create_class_name(element.type, @modulepath) 
     120      create_class_name(element.type, modulepath) 
    120121    elsif element.ref 
    121       create_class_name(element.ref, @modulepath) 
    122     else 
    123       nil 
    124       # nil means anyType. 
    125       # TODO: do we define a class for local complexType from it's name? 
    126       #   create_class_name(element.name, @modulepath) 
    127       # 
    128       # <element> 
    129       #   <complexType> 
    130       #     <seq...> 
    131       #   </complexType> 
    132       # </element> 
     122      create_class_name(element.ref, modulepath) 
     123    elsif element.anonymous_type? 
     124      # inner class 
     125      create_class_name(element.name, modulepath) 
     126    else 
     127      nil 
    133128    end 
    134129  end 
  • trunk/lib/wsdl/soap/element.rb

    r1827 r1915  
    2020  end 
    2121 
     22  def anonymous_type? 
     23    !@ref and @name and @local_complextype 
     24  end 
     25 
    2226  def attributes 
    2327    @local_complextype.attributes 
  • trunk/lib/wsdl/soap/encodedMappingRegistryCreator.rb

    r1895 r1915  
    7676  end 
    7777 
    78   def dump_struct_typemap(qname, typedef) 
    79     var = {} 
    80     var[:class] = create_class_name(qname, @modulepath) 
    81     var[:schema_ns] = qname.namespace 
    82     if typedef.name.nil? 
    83       # local complextype of a element 
    84       var[:schema_name] = qname.name 
    85     else 
    86       # named complextype 
    87       var[:schema_type] = qname.name 
    88     end 
    89     parsed_element = parse_elements(typedef.elements, qname.namespace) 
    90     var[:schema_element] = dump_schema_element_definition(parsed_element, 2) 
    91     assign_const(var[:schema_ns], 'Ns') 
    92     dump_entry(@varname, var) 
    93   end 
    94  
    9578  def dump_array_typemap(qname, typedef) 
    9679    arytype = typedef.find_arytype || XSD::AnyTypeName 
     
    10689__EOD__ 
    10790  end 
    108  
    109   def dump_simple_typemap(qname, typedef) 
    110     var = {} 
    111     var[:class] = create_class_name(qname, @modulepath) 
    112     var[:schema_ns] = qname.namespace 
    113     var[:schema_type] = qname.name 
    114     assign_const(var[:schema_ns], 'Ns') 
    115     dump_entry(@varname, var) 
    116   end 
    11791end 
    11892 
  • trunk/lib/wsdl/soap/literalMappingRegistryCreator.rb

    r1895 r1915  
    119119  end 
    120120 
    121   def dump_struct_typemap(qname, typedef, as_element = nil, qualified = false) 
    122     var = {} 
    123     var[:class] = create_class_name(qname, @modulepath) 
    124     if as_element 
    125       var[:schema_name] = as_element.name 
    126       var[:schema_ns] = as_element.namespace 
    127     elsif typedef.name.nil? 
    128       var[:schema_name] = qname.name 
    129       var[:schema_ns] = qname.namespace 
    130     else 
    131       var[:schema_type] = qname.name 
    132       var[:schema_ns] = qname.namespace 
    133     end 
    134     var[:schema_qualified] = qualified.to_s 
    135  
    136     parsed_element = parse_elements(typedef.elements, qname.namespace) 
    137     if typedef.choice? 
    138       parsed_element.unshift(:choice) 
    139     end 
    140     var[:schema_element] = dump_schema_element_definition(parsed_element, 2) 
    141     unless typedef.attributes.empty? 
    142       var[:schema_attribute] = define_attribute(typedef.attributes) 
    143     end 
    144     assign_const(var[:schema_ns], 'Ns') 
    145     dump_entry(@varname, var) 
    146   end 
    147  
    148121  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item') 
    149122 
     
    191164    dump_entry(@varname, var) 
    192165  end 
    193  
    194   def dump_simple_typemap(qname, type_or_element, as_element, qualified) 
    195     var = {} 
    196     var[:class] = create_class_name(qname, @modulepath) 
    197     if as_element 
    198       var[:schema_name] = as_element.name 
    199       var[:schema_ns] = as_element.namespace 
    200     elsif type_or_element.name.nil? 
    201       var[:schema_name] = qname.name 
    202       var[:schema_ns] = qname.namespace 
    203     else 
    204       var[:schema_type] = qname.name 
    205       var[:schema_ns] = qname.namespace 
    206     end 
    207     unless type_or_element.attributes.empty? 
    208       var[:schema_attribute] = define_attribute(type_or_element.attributes) 
    209     end 
    210     assign_const(var[:schema_ns], 'Ns') 
    211     dump_entry(@varname, var) 
    212   end 
    213166end 
    214167 
  • trunk/lib/wsdl/soap/mappingRegistryCreatorSupport.rb

    r1914 r1915  
    1414 
    1515 
    16 # requires @defined_const = {} 
     16# requires @defined_const = {}, @dump_struct_typemap_innerstruct 
    1717module MappingRegistryCreatorSupport 
    1818  include ClassDefCreatorSupport 
    1919  include XSD::CodeGen 
     20 
     21  def dump_struct_typemap(qname, typedef, as_element = nil, qualified = nil) 
     22    @dump_struct_typemap_innerstruct = [] 
     23    @dump_struct_typemap_innerstruct.unshift( 
     24      dump_complex_typemap(qname, typedef, @modulepath, as_element, qualified)) 
     25    @dump_struct_typemap_innerstruct.join("\n") 
     26  end 
     27 
     28  def dump_complex_typemap(qname, typedef, parentmodule, as_element = nil, qualified = nil) 
     29    var = {} 
     30    var[:class] = create_class_name(qname, parentmodule) 
     31    if as_element 
     32      var[:schema_name] = as_element.name 
     33      var[:schema_ns] = as_element.namespace 
     34    elsif typedef.name.nil? 
     35      var[:schema_name] = qname.name 
     36      var[:schema_ns] = qname.namespace 
     37    else 
     38      var[:schema_type] = qname.name 
     39      var[:schema_ns] = qname.namespace 
     40    end 
     41    # true, false, or nil 
     42    unless qualified.nil? 
     43      var[:schema_qualified] = qualified.to_s 
     44    end 
     45    parentmodule = var[:class] 
     46    parsed_element = parse_elements(typedef.elements, qname.namespace, 
     47      parentmodule, qualified) 
     48    if typedef.choice? 
     49      parsed_element.unshift(:choice) 
     50    end 
     51    var[:schema_element] = dump_schema_element_definition(parsed_element, 2) 
     52    unless typedef.attributes.empty? 
     53      var[:schema_attribute] = define_attribute(typedef.attributes) 
     54    end 
     55    assign_const(var[:schema_ns], 'Ns') 
     56    dump_entry(@varname, var) 
     57  end 
     58 
     59  def dump_simple_typemap(qname, typedef, as_element = nil, qualified = nil) 
     60    var = {} 
     61    var[:class] = create_class_name(qname, @modulepath) 
     62    if as_element 
     63      var[:schema_name] = as_element.name 
     64      var[:schema_ns] = as_element.namespace 
     65    elsif typedef.name.nil? 
     66      var[:schema_name] = qname.name 
     67      var[:schema_ns] = qname.namespace 
     68    else 
     69      var[:schema_type] = qname.name 
     70      var[:schema_ns] = qname.namespace 
     71    end 
     72    unless typedef.attributes.empty? 
     73      var[:schema_attribute] = define_attribute(typedef.attributes) 
     74    end 
     75    assign_const(var[:schema_ns], 'Ns') 
     76    dump_entry(@varname, var) 
     77  end 
    2078 
    2179  def dump_schema_element_definition(definition, indent = 0) 
     
    64122  end 
    65123 
    66   def parse_elements(elements, base_namespace
     124  def parse_elements(elements, base_namespace, parentmodule, qualified = false
    67125    schema_element = [] 
    68126    any = false 
     
    80138      when XMLSchema::Element 
    81139        next if element.ref == SchemaName 
    82         type = create_type_name(element) 
     140        typebase = @modulepath 
     141        if element.anonymous_type? 
     142          @dump_struct_typemap_innerstruct << 
     143            dump_complex_typemap(element.name, element.local_complextype, 
     144              parentmodule, nil, qualified) 
     145          typebase = parentmodule 
     146        end 
     147        type = create_type_name(element, typebase) 
    83148        name = name_element(element).name 
    84149        varname = safevarname(name) 
     
    98163        schema_element << [varname, eleqname, type, occurrence] 
    99164      when WSDL::XMLSchema::Sequence 
    100         child_schema_element = parse_elements(element.elements, base_namespace) 
     165        child_schema_element = 
     166          parse_elements(element.elements, base_namespace, parentmodule, qualified) 
    101167        schema_element << child_schema_element 
    102168      when WSDL::XMLSchema::Choice 
    103         child_schema_element = parse_elements(element.elements, base_namespace) 
     169        child_schema_element = 
     170          parse_elements(element.elements, base_namespace, parentmodule, qualified) 
    104171        child_schema_element.unshift(:choice) 
    105172        schema_element << child_schema_element 
     
    109176          next 
    110177        end 
    111         child_schema_element = parse_elements(element.content.elements, base_namespace) 
     178        child_schema_element = 
     179          parse_elements(element.content.elements, base_namespace, parentmodule, qualified) 
    112180        schema_element.concat(child_schema_element) 
    113181      else 
  • trunk/lib/xsd/codegen/classdef.rb

    r1824 r1915  
    6060      spacer = true 
    6161      buf << dump_const 
     62    end 
     63    unless @innermodule.empty? 
     64      buf << dump_emptyline # always add 1 empty line 
     65      spacer = true 
     66      buf << dump_innermodule 
    6267    end 
    6368    unless @code.empty? 
  • trunk/lib/xsd/codegen/moduledef.rb

    r1824 r1915  
    1919  include GenSupport 
    2020  include CommentDef 
     21 
     22  attr_reader :innermodule 
    2123 
    2224  def initialize(name) 
     
    2729    @requirepath = [] 
    2830    @methoddef = [] 
     31    @innermodule = [] 
    2932  end 
    3033 
     
    7881      buf << dump_const 
    7982    end 
     83    unless @innermodule.empty? 
     84      buf << dump_emptyline # always add 1 empty line 
     85      spacer = true 
     86      buf << dump_innermodule 
     87    end 
    8088    unless @code.empty? 
    8189      buf << dump_emptyline if spacer 
     
    107115      @const.sort.collect { |var, value| 
    108116        %Q(#{var} = #{dump_value(value)}) 
     117      }.join("\n") 
     118    ) 
     119  end 
     120 
     121  def dump_innermodule 
     122    dump_static( 
     123      @innermodule.collect { |moduledef| 
     124        moduledef.dump 
    109125      }.join("\n") 
    110126    ) 
  • trunk/test/wsdl/any/expectedEcho.rb

    r1891 r1915  
    2525# {urn:example.com:echo-type}setOutputAndCompleteRequest 
    2626#   taskId - SOAP::SOAPString 
    27 #   data - (any) 
     27#   data - SetOutputAndCompleteRequest::C_Data 
    2828#   participantToken - SOAP::SOAPString 
    2929class SetOutputAndCompleteRequest 
     30 
     31  # inner class for member: data 
     32  # {}data 
     33  class C_Data 
     34    attr_reader :__xmlele_any 
     35 
     36    def set_any(elements) 
     37      @__xmlele_any = elements 
     38    end 
     39 
     40    def initialize 
     41      @__xmlele_any = nil 
     42    end 
     43  end 
     44 
    3045  attr_accessor :taskId 
    3146  attr_accessor :data 
  • trunk/test/wsdl/any/expectedMappingRegistry.rb

    r1904 r1915  
    5252    :schema_element => [ 
    5353      ["taskId", ["SOAP::SOAPString", XSD::QName.new(nil, "taskId")]], 
    54       ["data", [nil, XSD::QName.new(nil, "data")]], 
     54      ["data", ["WSDL::Any::SetOutputAndCompleteRequest::C_Data", XSD::QName.new(nil, "data")]], 
    5555      ["participantToken", ["SOAP::SOAPString", XSD::QName.new(nil, "participantToken")]] 
     56    ] 
     57  ) 
     58 
     59  LiteralRegistry.register( 
     60    :class => WSDL::Any::SetOutputAndCompleteRequest::C_Data, 
     61    :schema_ns => nil, 
     62    :schema_name => "data", 
     63    :schema_qualified => true, 
     64    :schema_element => [ 
     65      ["any", [nil, XSD::QName.new(NsXMLSchema, "anyType")]] 
    5666    ] 
    5767  ) 
  • trunk/test/wsdl/ref/expectedProduct.rb

    r1891 r1915  
    135135#   bag - WSDL::Ref::Product 
    136136#   rating - SOAP::SOAPString 
    137 #   comment_1 - (any) 
     137#   comment_1 - ProductBag::Comment_1 
    138138#   comment_2 - WSDL::Ref::Comment 
    139139#   m___point - WSDL::Ref::C__point 
     
    144144  AttrYesno = XSD::QName.new("urn:ref", "yesno") 
    145145 
     146  # inner class for member: Comment_1 
     147  # {}Comment_1 
     148  #   xmlattr_msgid - SOAP::SOAPString 
     149  class Comment_1 
     150    AttrMsgid = XSD::QName.new(nil, "msgid") 
     151 
     152    def __xmlattr 
     153      @__xmlattr ||= {} 
     154    end 
     155 
     156    def xmlattr_msgid 
     157      __xmlattr[AttrMsgid] 
     158    end 
     159 
     160    def xmlattr_msgid=(value) 
     161      __xmlattr[AttrMsgid] = value 
     162    end 
     163 
     164    def initialize 
     165      @__xmlattr = {} 
     166    end 
     167  end 
     168 
    146169  attr_accessor :bag 
    147170  attr_accessor :rating 
  • trunk/test/xsd/codegen/test_classdef.rb

    r1380 r1915  
    8787 
    8888        def bar 
     89        end 
     90      end 
     91    EOD 
     92  end 
     93 
     94  def test_innermodule 
     95    c = ClassDef.new("Foo") 
     96    c.def_const("BAR", 1) 
     97    c.def_method('baz') { "Qux.new.quxx" } 
     98    c2 = ClassDef.new("Qux") 
     99    c2.def_method('quxx') { "Quxx::QUXXX" } 
     100    m3 = ModuleDef.new("Quxx") 
     101    m3.def_const("QUXXX", 2) 
     102    c.innermodule << c2 << m3 
     103    assert_equal(format(<<-EOD), c.dump) 
     104      class Foo 
     105        BAR = 1 
     106 
     107        class Qux 
     108          def quxx 
     109            Quxx::QUXXX 
     110          end 
     111        end 
     112 
     113        module Quxx 
     114          QUXXX = 2 
     115        end 
     116 
     117        def baz 
     118          Qux.new.quxx 
    89119        end 
    90120      end