1 files changed, 119 insertions, 37 deletions

diff --git a/lib/wsdl/soap/classDefCreator.rb b/lib/wsdl/soap/classDefCreator.rb
index 6c7d381932..13f7802b72 100644
--- a/lib/wsdl/soap/classDefCreator.rb
+++ b/lib/wsdl/soap/classDefCreator.rb
@@ -19,42 +19,71 @@ class ClassDefCreator
   include ClassDefCreatorSupport
 
   def initialize(definitions)
+    @elements = definitions.collect_elements
     @simpletypes = definitions.collect_simpletypes
     @complextypes = definitions.collect_complextypes
-    @faulttypes = definitions.collect_faulttypes
+    @faulttypes = definitions.collect_faulttypes if definitions.respond_to?(:collect_faulttypes)
   end
 
   def dump(class_name = nil)
-    result = ""
+    result = ''
     if class_name
       result = dump_classdef(class_name)
     else
-      @complextypes.each do |type|
-	case type.compoundtype
-	when :TYPE_STRUCT
-	  result << dump_classdef(type)
-	when :TYPE_ARRAY
-	  result << dump_arraydef(type)
-       	else
-	  raise RuntimeError.new("Unknown complexContent definition...")
-	end
-	result << "\n"
+      str = dump_element
+      unless str.empty?
+        result << "\n" unless result.empty?
+        result << str
+      end
+      str = dump_complextype
+      unless str.empty?
+        result << "\n" unless result.empty?
+        result << str
+      end
+      str = dump_simpletype
+      unless str.empty?
+        result << "\n" unless result.empty?
+        result << str
       end
-
-      result << @simpletypes.collect { |type|
-        dump_simpletypedef(type)
-      }.join("\n")
     end
     result
   end
 
 private
 
+  def dump_element
+    @elements.collect { |ele|
+      ele.local_complextype ? dump_classdef(ele) : ''
+    }.join("\n")
+  end
+
+  def dump_simpletype
+    @simpletypes.collect { |type|
+      dump_simpletypedef(type)
+    }.join("\n")
+  end
+
+  def dump_complextype
+    @complextypes.collect { |type|
+      case type.compoundtype
+      when :TYPE_STRUCT
+        dump_classdef(type)
+      when :TYPE_ARRAY
+        dump_arraydef(type)
+      when :TYPE_SIMPLE
+        STDERR.puts("not implemented: ToDo")
+      else
+        raise RuntimeError.new(
+          "Unknown kind of complexContent: #{type.compoundtype}")
+      end
+    }.join("\n")
+  end
+
   def dump_simpletypedef(simpletype)
     qname = simpletype.name
     if simpletype.restriction.enumeration.empty?
       STDERR.puts("#{qname}: simpleType which is not enum type not supported.")
-      return ""
+      return ''
     end
     c = XSD::CodeGen::ModuleDef.new(create_class_name(qname))
     c.comment = "#{ qname.namespace }"
@@ -64,45 +93,98 @@ private
     c.dump
   end
 
-  def dump_classdef(complextype)
-    qname = complextype.name
-    if @faulttypes.index(qname)
+  def dump_classdef(type_or_element)
+    qname = type_or_element.name
+    if @faulttypes and @faulttypes.index(qname)
       c = XSD::CodeGen::ClassDef.new(create_class_name(qname),
-        "::StandardError")
+        '::StandardError')
     else
       c = XSD::CodeGen::ClassDef.new(create_class_name(qname))
     end
     c.comment = "#{ qname.namespace }"
-    c.def_classvar("schema_type", qname.name.dump)
-    c.def_classvar("schema_ns", qname.namespace.dump)
-    init_lines = ""
+    c.def_classvar('schema_type', qname.name.dump)
+    c.def_classvar('schema_ns', qname.namespace.dump)
+    schema_attribute = []
+    schema_element = []
+    init_lines = ''
     params = []
-    complextype.each_element do |element|
+    type_or_element.each_element do |element|
+      next unless element.name
       name = element.name.name
+      if element.type == XSD::AnyTypeName
+        type = nil
+      elsif basetype = basetype_class(element.type)
+        type = basetype.name
+      else
+        type = create_class_name(element.type)
+      end
+      attrname = safemethodname?(name) ? name : safemethodname(name)
       varname = safevarname(name)
-      c.def_attr(name, true, varname)
+      c.def_attr(attrname, true, varname)
       init_lines << "@#{ varname } = #{ varname }\n"
-      params << "#{ varname } = nil"
+      if element.map_as_array?
+        params << "#{ varname } = []"
+        type << '[]'
+      else
+        params << "#{ varname } = nil"
+      end
+      schema_element << [name, type]
     end
-    complextype.attributes.each do |attribute|
-      name = "attr_" + attribute.name
-      varname = safevarname(name)
-      c.def_attr(name, true, varname)
-      init_lines << "@#{ varname } = #{ varname }\n"
-      params << "#{ varname } = nil"
+    unless type_or_element.attributes.empty?
+      type_or_element.attributes.each do |attribute|
+        name = attribute.name.name
+        if basetype = basetype_class(attribute.type)
+          type = basetype_class(attribute.type).name
+        else
+          type = nil
+        end
+        varname = safevarname('attr_' + name)
+        c.def_method(varname) do <<-__EOD__
+            @__soap_attribute[#{name.dump}]
+          __EOD__
+        end
+        c.def_method(varname + '=', 'value') do <<-__EOD__
+            @__soap_attribute[#{name.dump}] = value
+          __EOD__
+        end
+        schema_attribute << [name, type]
+      end
+      init_lines << "@__soap_attribute = {}\n"
     end
-    c.def_method("initialize", *params) do
+    c.def_classvar('schema_attribute',
+      '{' +
+        schema_attribute.collect { |name, type|
+          name.dump + ' => ' + ndq(type)
+        }.join(', ') +
+      '}'
+    )
+    c.def_classvar('schema_element',
+      '{' +
+        schema_element.collect { |name, type|
+          name.dump + ' => ' + ndq(type)
+        }.join(', ') +
+      '}'
+    )
+    c.def_method('initialize', *params) do
       init_lines
     end
     c.dump
   end
 
+  def basetype_class(type)
+    if @simpletypes[type]
+      basetype_mapped_class(@simpletypes[type].base)
+    else
+      basetype_mapped_class(type)
+    end
+  end
+
   def dump_arraydef(complextype)
     qname = complextype.name
-    c = XSD::CodeGen::ClassDef.new(create_class_name(qname), "::Array")
+    c = XSD::CodeGen::ClassDef.new(create_class_name(qname), '::Array')
     c.comment = "#{ qname.namespace }"
-    c.def_classvar("schema_type", qname.name.dump)
-    c.def_classvar("schema_ns", qname.namespace.dump)
+    c.def_classvar('schema_type', qname.name.dump)
+    c.def_classvar('schema_ns', qname.namespace.dump)
     c.dump
   end
 end