1 files changed, 152 insertions, 74 deletions

diff --git a/lib/wsdl/soap/classDefCreator.rb b/lib/wsdl/soap/classDefCreator.rb
index 13f7802b72..deda4f131f 100644
--- a/lib/wsdl/soap/classDefCreator.rb
+++ b/lib/wsdl/soap/classDefCreator.rb
@@ -1,5 +1,5 @@
 # WSDL4R - Creating class definition from WSDL
-# Copyright (C) 2002, 2003  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2002, 2003, 2004  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;
@@ -22,13 +22,16 @@ class ClassDefCreator
     @elements = definitions.collect_elements
     @simpletypes = definitions.collect_simpletypes
     @complextypes = definitions.collect_complextypes
-    @faulttypes = definitions.collect_faulttypes if definitions.respond_to?(:collect_faulttypes)
+    @faulttypes = nil
+    if definitions.respond_to?(:collect_faulttypes)
+      @faulttypes = definitions.collect_faulttypes
+    end
   end
 
-  def dump(class_name = nil)
-    result = ''
-    if class_name
-      result = dump_classdef(class_name)
+  def dump(type = nil)
+    result = "require 'xsd/qname'\n"
+    if type
+      result = dump_classdef(type.name, type)
     else
       str = dump_element
       unless str.empty?
@@ -53,117 +56,129 @@ private
 
   def dump_element
     @elements.collect { |ele|
-      ele.local_complextype ? dump_classdef(ele) : ''
-    }.join("\n")
+      if ele.local_complextype
+        dump_classdef(ele.name, ele.local_complextype)
+      elsif ele.local_simpletype
+        dump_simpletypedef(ele.name, ele.local_simpletype)
+      else
+        nil
+      end
+    }.compact.join("\n")
   end
 
   def dump_simpletype
     @simpletypes.collect { |type|
-      dump_simpletypedef(type)
-    }.join("\n")
+      dump_simpletypedef(type.name, type)
+    }.compact.join("\n")
   end
 
   def dump_complextype
     @complextypes.collect { |type|
       case type.compoundtype
-      when :TYPE_STRUCT
-        dump_classdef(type)
+      when :TYPE_STRUCT, :TYPE_EMPTY
+        dump_classdef(type.name, type)
       when :TYPE_ARRAY
         dump_arraydef(type)
       when :TYPE_SIMPLE
-        STDERR.puts("not implemented: ToDo")
+        dump_simpleclassdef(type)
+      when :TYPE_MAP
+        # mapped as a general Hash
+        nil
       else
         raise RuntimeError.new(
-          "Unknown kind of complexContent: #{type.compoundtype}")
+          "unknown kind of complexContent: #{type.compoundtype}")
       end
-    }.join("\n")
+    }.compact.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 ''
+  def dump_simpletypedef(qname, simpletype)
+    if !simpletype.restriction or simpletype.restriction.enumeration.empty?
+      return nil
     end
     c = XSD::CodeGen::ModuleDef.new(create_class_name(qname))
-    c.comment = "#{ qname.namespace }"
+    c.comment = "#{qname}"
+    const = {}
     simpletype.restriction.enumeration.each do |value|
-      c.def_const(safeconstname(value), value.dump)
+      constname = safeconstname(value)
+      const[constname] ||= 0
+      if (const[constname] += 1) > 1
+        constname += "_#{const[constname]}"
+      end
+      c.def_const(constname, ndq(value))
     end
     c.dump
   end
 
-  def dump_classdef(type_or_element)
+  def dump_simpleclassdef(type_or_element)
     qname = type_or_element.name
+    base = create_class_name(type_or_element.simplecontent.base)
+    c = XSD::CodeGen::ClassDef.new(create_class_name(qname), base)
+    c.comment = "#{qname}"
+    c.dump
+  end
+
+  def dump_classdef(qname, typedef)
     if @faulttypes and @faulttypes.index(qname)
       c = XSD::CodeGen::ClassDef.new(create_class_name(qname),
         '::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)
-    schema_attribute = []
+    c.comment = "#{qname}"
+    c.def_classvar('schema_type', ndq(qname.name))
+    c.def_classvar('schema_ns', ndq(qname.namespace))
     schema_element = []
     init_lines = ''
     params = []
-    type_or_element.each_element do |element|
-      next unless element.name
-      name = element.name.name
+    typedef.each_element do |element|
       if element.type == XSD::AnyTypeName
         type = nil
-      elsif basetype = basetype_class(element.type)
-        type = basetype.name
-      else
+      elsif klass = element_basetype(element)
+        type = klass.name
+      elsif element.type
         type = create_class_name(element.type)
+      else
+        type = nil      # means anyType.
+        # do we define a class for local complexType from it's name?
+        #   type = create_class_name(element.name)
+        # <element>
+        #   <complexType>
+        #     <seq...>
+        #   </complexType>
+        # </element>
       end
+      name = name_element(element).name
       attrname = safemethodname?(name) ? name : safemethodname(name)
       varname = safevarname(name)
       c.def_attr(attrname, true, varname)
-      init_lines << "@#{ varname } = #{ varname }\n"
+      init_lines << "@#{varname} = #{varname}\n"
       if element.map_as_array?
-        params << "#{ varname } = []"
-        type << '[]'
+        params << "#{varname} = []"
+        type << '[]' if type
       else
-        params << "#{ varname } = nil"
+        params << "#{varname} = nil"
       end
-      schema_element << [name, type]
+      eleqname = (varname == name) ? nil : element.name
+      schema_element << [varname, eleqname, type]
     end
-    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"
+    unless typedef.attributes.empty?
+      define_attribute(c, typedef.attributes)
+      init_lines << "@__xmlattr = {}\n"
     end
-    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)
+      '[' +
+        schema_element.collect { |varname, name, type|
+          '[' +
+            (
+              if name
+                varname.dump + ', [' + ndq(type) + ', ' + dqname(name) + ']'
+              else
+                varname.dump + ', ' + ndq(type)
+              end
+            ) +
+          ']'
         }.join(', ') +
-      '}'
+      ']'
     )
     c.def_method('initialize', *params) do
       init_lines
@@ -171,20 +186,83 @@ private
     c.dump
   end
 
+  def element_basetype(ele)
+    if klass = basetype_class(ele.type)
+      klass
+    elsif ele.local_simpletype
+      basetype_class(ele.local_simpletype.base)
+    else
+      nil
+    end
+  end
+
+  def attribute_basetype(attr)
+    if klass = basetype_class(attr.type)
+      klass
+    elsif attr.local_simpletype
+      basetype_class(attr.local_simpletype.base)
+    else
+      nil
+    end
+  end
+
   def basetype_class(type)
-    if @simpletypes[type]
-      basetype_mapped_class(@simpletypes[type].base)
+    return nil if type.nil?
+    if simpletype = @simpletypes[type]
+      basetype_mapped_class(simpletype.base)
     else
       basetype_mapped_class(type)
     end
   end
 
+  def define_attribute(c, attributes)
+    schema_attribute = []
+    attributes.each do |attribute|
+      name = name_attribute(attribute)
+      if klass = attribute_basetype(attribute)
+        type = klass.name
+      else
+        type = nil
+      end
+      methodname = safemethodname('xmlattr_' + name.name)
+      c.def_method(methodname) do <<-__EOD__
+          (@__xmlattr ||= {})[#{dqname(name)}]
+        __EOD__
+      end
+      c.def_method(methodname + '=', 'value') do <<-__EOD__
+          (@__xmlattr ||= {})[#{dqname(name)}] = value
+        __EOD__
+      end
+      schema_attribute << [name, type]
+    end
+    c.def_classvar('schema_attribute',
+      '{' +
+        schema_attribute.collect { |name, type|
+          dqname(name) + ' => ' + ndq(type)
+        }.join(', ') +
+      '}'
+    )
+  end
+
+  def name_element(element)
+    return element.name if element.name 
+    return element.ref if element.ref
+    raise RuntimeError.new("cannot define name of #{element}")
+  end
+
+  def name_attribute(attribute)
+    return attribute.name if attribute.name 
+    return attribute.ref if attribute.ref
+    raise RuntimeError.new("cannot define name of #{attribute}")
+  end
+
   def dump_arraydef(complextype)
     qname = complextype.name
     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.comment = "#{qname}"
+    type = complextype.child_type
+    c.def_classvar('schema_type', ndq(type.name))
+    c.def_classvar('schema_ns', ndq(type.namespace))
     c.dump
   end
 end