soap4r 1.5.7 → 1.5.8

data/lib/wsdl/definitions.rb

@@ -51,55 +51,28 @@ class Definitions < Info
   end
 
   def collect_attributes
-    result = XSD::NamedElements.new
-    if @types
-      @types.schemas.each do |schema|
-	result.concat(schema.collect_attributes)
-      end
-    end
-    @imports.each do |import|
-      result.concat(import.content.collect_attributes)
-    end
-    result
+    collect_imports(:collect_attributes)
+  end
+
+  def collect_modelgroups
+    collect_imports(:collect_modelgroups)
+  end
+
+  def collect_attributegroups
+    collect_imports(:collect_attributegroups)
   end
 
   def collect_elements
-    result = XSD::NamedElements.new
-    if @types
-      @types.schemas.each do |schema|
-	result.concat(schema.collect_elements)
-      end
-    end
-    @imports.each do |import|
-      result.concat(import.content.collect_elements)
-    end
-    result
+    collect_imports(:collect_elements)
   end
 
   def collect_complextypes
-    result = @anontypes.dup
-    if @types
-      @types.schemas.each do |schema|
-	result.concat(schema.collect_complextypes)
-      end
-    end
-    @imports.each do |import|
-      result.concat(import.content.collect_complextypes)
-    end
-    result
+    result = collect_imports(:collect_complextypes)
+    @anontypes.dup.concat(result)
   end
 
   def collect_simpletypes
-    result = XSD::NamedElements.new
-    if @types
-      @types.schemas.each do |schema|
-	result.concat(schema.collect_simpletypes)
-      end
-    end
-    @imports.each do |import|
-      result.concat(import.content.collect_simpletypes)
-    end
-    result
+    collect_imports(:collect_simpletypes)
   end
 
   # ToDo: simpletype must be accepted...
@@ -244,6 +217,19 @@ class Definitions < Info
 
 private
 
+  def collect_imports(method)
+    result = XSD::NamedElements.new
+    if @types
+      @types.schemas.each do |schema|
+	result.concat(schema.send(method))
+      end
+    end
+    @imports.each do |import|
+      result.concat(import.content.send(method))
+    end
+    result
+  end
+
 end
 
 

data/lib/wsdl/info.rb

@@ -33,6 +33,17 @@ class Info
   def parse_attr(attr, value); end	# abstract
 
   def parse_epilogue; end		# abstract
+
+private
+
+  def to_int(value)
+    Integer(value.source)
+  end
+
+  def to_boolean(value)
+    s = value.source
+    s == "true" or s == "1"
+  end
 end
 
 

data/lib/wsdl/parser.rb

@@ -7,10 +7,10 @@
 
 
 require 'xsd/qname'
-require 'xsd/ns'
 require 'xsd/charset'
 require 'xsd/datatypes'
 require 'xsd/xmlparser'
+require 'soap/ns'
 require 'wsdl/wsdl'
 require 'wsdl/data'
 require 'wsdl/xmlSchema/data'
@@ -77,7 +77,7 @@ public
       ns = lastframe.ns
       parent = lastframe.node
     else
-      ns = XSD::NS.new
+      ns = ::SOAP::NS.new
       parent = nil
     end
     # ns might be the same

data/lib/wsdl/soap/cgiStubCreator.rb

@@ -21,8 +21,9 @@ class CGIStubCreator
 
   attr_reader :definitions
 
-  def initialize(definitions, modulepath = nil)
+  def initialize(definitions, name_creator, modulepath = nil)
     @definitions = definitions
+    @name_creator = name_creator
     @modulepath = modulepath
   end
 
@@ -40,14 +41,15 @@ class CGIStubCreator
     if port.porttype.nil?
       raise RuntimeError.new("porttype not found for #{port}")
     end
-    dump_porttype(port.porttype.name)
+    dump_porttype(port.porttype)
   end
 
 private
 
-  def dump_porttype(name)
-    class_name = create_class_name(name, @modulepath)
-    result = MethodDefCreator.new(@definitions, @modulepath).dump(name)
+  def dump_porttype(porttype)
+    class_name = mapped_class_name(porttype.name, @modulepath)
+    defined_const = {}
+    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
     methoddef = result[:methoddef]
     wsdl_name = @definitions.name ? @definitions.name.name : 'default'
     mrname = safeconstname(wsdl_name + 'MappingRegistry')
@@ -58,6 +60,9 @@ Methods = [
 #{methoddef.gsub(/^/, "  ")}
 ]
     EOD
+    defined_const.each do |ns, tag|
+      c1.def_const(tag, dq(ns))
+    end
     c2 = XSD::CodeGen::ClassDef.new(class_name + "App",
       "::SOAP::RPC::CGIStub")
     c2.def_method("initialize", "*arg") do

data/lib/wsdl/soap/classDefCreator.rb

@@ -9,6 +9,7 @@
 require 'wsdl/data'
 require 'wsdl/soap/classDefCreatorSupport'
 require 'xsd/codegen'
+require 'set'
 
 
 module WSDL
@@ -19,8 +20,9 @@ class ClassDefCreator
   include ClassDefCreatorSupport
   include XSD::CodeGen
 
-  def initialize(definitions, modulepath = nil)
+  def initialize(definitions, name_creator, modulepath = nil)
     @definitions = definitions
+    @name_creator = name_creator
     @modulepath = modulepath
     @elements = definitions.collect_elements
     @elements.uniq!
@@ -30,22 +32,31 @@ class ClassDefCreator
     @simpletypes.uniq!
     @complextypes = definitions.collect_complextypes
     @complextypes.uniq!
+    @modelgroups = definitions.collect_modelgroups
+    @modelgroups.uniq!
     @faulttypes = nil
     if definitions.respond_to?(:collect_faulttypes)
       @faulttypes = definitions.collect_faulttypes
     end
+    @defined_const = {}
   end
 
   def dump(type = nil)
     result = "require 'xsd/qname'\n"
+    # cannot use @modulepath because of multiple classes
     if @modulepath
       result << "\n"
-      result << @modulepath.collect { |ele| "module #{ele}" }.join("; ")
+      result << modulepath_split(@modulepath).collect { |ele| "module #{ele}" }.join("; ")
       result << "\n\n"
     end
     if type
       result << dump_classdef(type.name, type)
     else
+      str = dump_group
+      unless str.empty?
+        result << "\n" unless result.empty?
+        result << str
+      end
       str = dump_complextype
       unless str.empty?
         result << "\n" unless result.empty?
@@ -69,7 +80,7 @@ class ClassDefCreator
     end
     if @modulepath
       result << "\n\n"
-      result << @modulepath.collect { |ele| "end" }.join("; ")
+      result << modulepath_split(@modulepath).collect { |ele| "end" }.join("; ")
       result << "\n"
     end
     result
@@ -79,69 +90,83 @@ private
 
   def dump_element
     @elements.collect { |ele|
-      qualified = (ele.elementform == 'qualified')
-      if ele.local_complextype
-        dump_complextypedef(ele.name, ele.local_complextype, qualified)
-      elsif ele.local_simpletype
-        dump_simpletypedef(ele.name, ele.local_simpletype, qualified)
-      elsif ele.empty?
-        dump_simpleclassdef(ele.name, nil)
-      else
-        nil
-      end
+      next if @complextypes[ele.name]
+      c = create_elementdef(@modulepath, ele)
+      c ? c.dump : nil
     }.compact.join("\n")
   end
 
   def dump_attribute
-    @attributes.collect { |attr|
-      if attr.local_simpletype
-        dump_simpletypedef(attr.name, attr.local_simpletype)
+    @attributes.collect { |attribute|
+      if attribute.local_simpletype
+        c = create_simpletypedef(@modulepath, attribute.name, attribute.local_simpletype)
       end
+      c ? c.dump : nil
     }.compact.join("\n")
   end
 
   def dump_simpletype
     @simpletypes.collect { |type|
-      dump_simpletypedef(type.name, type)
+      c = create_simpletypedef(@modulepath, type.name, type)
+      c ? c.dump : nil
     }.compact.join("\n")
   end
 
   def dump_complextype
     definitions = sort_dependency(@complextypes).collect { |type|
-      dump_complextypedef(type.name, type)
+      c = create_complextypedef(@modulepath, type.name, type)
+      c ? c.dump : nil
+    }.compact.join("\n")
+  end
+
+  def dump_group
+    definitions = @modelgroups.collect { |group|
+      # TODO: not dumped for now but may be useful in the future
     }.compact.join("\n")
   end
 
-  def dump_simpletypedef(qname, simpletype, qualified = false)
+  def create_elementdef(mpath, ele)
+    qualified = (ele.elementform == 'qualified')
+    if ele.local_complextype
+      create_complextypedef(mpath, ele.name, ele.local_complextype, qualified)
+    elsif ele.local_simpletype
+      create_simpletypedef(mpath, ele.name, ele.local_simpletype, qualified)
+    elsif ele.empty?
+      create_simpleclassdef(mpath, ele.name, nil)
+    else
+      # ignores type only element
+      nil
+    end
+  end
+
+  def create_simpletypedef(mpath, qname, simpletype, qualified = false)
     if simpletype.restriction
-      dump_simpletypedef_restriction(qname, simpletype, qualified)
+      create_simpletypedef_restriction(mpath, qname, simpletype, qualified)
     elsif simpletype.list
-      dump_simpletypedef_list(qname, simpletype, qualified)
+      create_simpletypedef_list(mpath, qname, simpletype, qualified)
     elsif simpletype.union
-      dump_simpletypedef_union(qname, simpletype, qualified)
+      create_simpletypedef_union(mpath, qname, simpletype, qualified)
     else
       raise RuntimeError.new("unknown kind of simpletype: #{simpletype}")
     end
   end
 
-  def dump_simpletypedef_restriction(qname, typedef, qualified)
+  def create_simpletypedef_restriction(mpath, qname, typedef, qualified)
     restriction = typedef.restriction
-    if restriction.enumeration.empty?
+    unless restriction.enumeration?
       # not supported.  minlength?
       return nil
     end
-    classname = create_class_name(qname)
-    check_classname(classname)
+    classname = mapped_class_basename(qname, mpath)
     c = ClassDef.new(classname, '::String')
     c.comment = "#{qname}"
     define_classenum_restriction(c, classname, restriction.enumeration)
-    c.dump
+    c
   end
 
-  def dump_simpletypedef_list(qname, typedef, qualified)
+  def create_simpletypedef_list(mpath, qname, typedef, qualified)
     list = typedef.list
-    classname = create_class_name(qname)
-    check_classname(classname)
+    classname = mapped_class_basename(qname, mpath)
     c = ClassDef.new(classname, '::Array')
     c.comment = "#{qname}"
     if simpletype = list.local_simpletype
@@ -152,22 +177,23 @@ private
       define_stringenum_restriction(c, simpletype.restriction.enumeration)
       c.comment << "\n  contains list of #{classname}::*"
     elsif list.itemtype
-      c.comment << "\n  contains list of #{create_class_name(list.itemtype)}::*"
+      c.comment << "\n  contains list of #{mapped_class_basename(list.itemtype, mpath)}::*"
     else
       raise RuntimeError.new("unknown kind of list: #{list}")
     end
-    c.dump
+    c
   end
 
-  def dump_simpletypedef_union(qname, typedef, qualified)
+  def create_simpletypedef_union(mpath, qname, typedef, qualified)
     union = typedef.union
-    c = ClassDef.new(create_class_name(qname), '::String')
+    classname = mapped_class_basename(qname, mpath)
+    c = ClassDef.new(classname, '::String')
     c.comment = "#{qname}"
     if union.member_types
       # fixme
       c.comment << "\n any of #{union.member_types}"
     end
-    c.dump
+    c
   end
 
   def define_stringenum_restriction(c, enumeration)
@@ -194,9 +220,8 @@ private
     end
   end
 
-  def dump_simpleclassdef(qname, type_or_element)
-    classname = create_class_name(qname)
-    check_classname(classname)
+  def create_simpleclassdef(mpath, qname, type_or_element)
+    classname = mapped_class_basename(qname, mpath)
     c = ClassDef.new(classname, '::String')
     c.comment = "#{qname}"
     init_lines = []
@@ -207,17 +232,17 @@ private
     c.def_method('initialize', '*arg') do
       "super\n" + init_lines.join("\n")
     end
-    c.dump
+    c
   end
 
-  def dump_complextypedef(qname, type, qualified = false)
+  def create_complextypedef(mpath, qname, type, qualified = false)
     case type.compoundtype
     when :TYPE_STRUCT, :TYPE_EMPTY
-      dump_classdef(qname, type, qualified)
+      create_structdef(mpath, qname, type, qualified)
     when :TYPE_ARRAY
-      dump_arraydef(qname, type)
+      create_arraydef(mpath, qname, type)
     when :TYPE_SIMPLE
-      dump_simpleclassdef(qname, type)
+      create_simpleclassdef(mpath, qname, type)
     when :TYPE_MAP
       # mapped as a general Hash
       nil
@@ -227,13 +252,17 @@ private
     end
   end
 
-  def dump_classdef(qname, typedef, qualified = false)
-    classname = create_class_name(qname)
-    check_classname(classname)
+  def create_structdef(mpath, qname, typedef, qualified = false)
+    classname = mapped_class_basename(qname, mpath)
     baseclassname = nil
     if typedef.complexcontent
       if base = typedef.complexcontent.base
-        baseclassname = create_class_name(base)
+        # :TYPE_ARRAY must not be derived (#424)
+        basedef = @complextypes[base]
+        if basedef and basedef.compoundtype != :TYPE_ARRAY
+          # baseclass should be a toplevel complexType
+          baseclassname = mapped_class_basename(base, @modulepath)
+        end
       end
     end
     if @faulttypes and @faulttypes.index(qname)
@@ -243,8 +272,9 @@ private
     end
     c.comment = "#{qname}"
     c.comment << "\nabstract" if typedef.abstract
+    parentmodule = mapped_class_name(qname, mpath)
     init_lines, init_params =
-      parse_elements(c, typedef.elements, qname.namespace)
+      parse_elements(c, typedef.elements, qname.namespace, parentmodule)
     unless typedef.attributes.empty?
       define_attribute(c, typedef.attributes)
       init_lines << "@__xmlattr = {}"
@@ -252,10 +282,10 @@ private
     c.def_method('initialize', *init_params) do
       init_lines.join("\n")
     end
-    c.dump
+    c
   end
 
-  def parse_elements(c, elements, base_namespace)
+  def parse_elements(c, elements, base_namespace, mpath, as_array = false)
     init_lines = []
     init_params = []
     any = false
@@ -274,23 +304,44 @@ private
       when XMLSchema::Element
         next if element.ref == SchemaName
         name = name_element(element).name
-        attrname = safemethodname(name)
-        varname = safevarname(name)
-        c.def_attr(attrname, true, varname)
-        init_lines << "@#{varname} = #{varname}"
-        if element.map_as_array?
-          init_params << "#{varname} = []"
-        else
-          init_params << "#{varname} = nil"
+        typebase = @modulepath
+        if element.anonymous_type?
+          inner = create_elementdef(mpath, element)
+          unless as_array
+            inner.comment = "inner class for member: #{name}\n" + inner.comment
+          end
+          c.innermodule << inner
+          typebase = mpath
+        end
+        unless as_array
+          attrname = safemethodname(name)
+          varname = safevarname(name)
+          c.def_attr(attrname, true, varname)
+          init_lines << "@#{varname} = #{varname}"
+          if element.map_as_array?
+            init_params << "#{varname} = []"
+          else
+            init_params << "#{varname} = nil"
+          end
+          c.comment << "\n  #{attrname} - #{create_type_name(typebase, element) || '(any)'}"
         end
       when WSDL::XMLSchema::Sequence
         child_init_lines, child_init_params =
-          parse_elements(c, element.elements, base_namespace)
+          parse_elements(c, element.elements, base_namespace, mpath, as_array)
         init_lines.concat(child_init_lines)
         init_params.concat(child_init_params)
       when WSDL::XMLSchema::Choice
         child_init_lines, child_init_params =
-          parse_elements(c, element.elements, base_namespace)
+          parse_elements(c, element.elements, base_namespace, mpath, as_array)
+        init_lines.concat(child_init_lines)
+        init_params.concat(child_init_params)
+      when WSDL::XMLSchema::Group
+        if element.content.nil?
+          warn("no group definition found: #{element}")
+          next
+        end
+        child_init_lines, child_init_params =
+          parse_elements(c, element.content.elements, base_namespace, mpath, as_array)
         init_lines.concat(child_init_lines)
         init_params.concat(child_init_params)
       else
@@ -300,74 +351,42 @@ private
     [init_lines, init_params]
   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)
-    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)
+    const = {}
+    unless attributes.empty?
+      c.def_method("__xmlattr") do <<-__EOD__
+          @__xmlattr ||= {}
+        __EOD__
+      end
+    end
     attributes.each do |attribute|
       name = name_attribute(attribute)
       methodname = safemethodname('xmlattr_' + name.name)
+      constname = 'Attr' + safeconstname(name.name)
+      const[constname] ||= 0
+      if (const[constname] += 1) > 1
+        constname += "_#{const[constname]}"
+      end
+      c.def_const(constname, dqname(name))
       c.def_method(methodname) do <<-__EOD__
-          (@__xmlattr ||= {})[#{dqname(name)}]
+          __xmlattr[#{constname}]
         __EOD__
       end
       c.def_method(methodname + '=', 'value') do <<-__EOD__
-          (@__xmlattr ||= {})[#{dqname(name)}] = value
+          __xmlattr[#{constname}] = value
         __EOD__
       end
+      c.comment << "\n  #{methodname} - #{attribute_basetype(attribute) || '(any)'}"
     end
   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(qname, complextype)
-    classname = create_class_name(qname)
-    check_classname(classname)
+  def create_arraydef(mpath, qname, typedef)
+    classname = mapped_class_basename(qname, mpath)
     c = ClassDef.new(classname, '::Array')
     c.comment = "#{qname}"
-    c.dump
-  end
-
-  def check_classname(classname)
-    if @modulepath.nil? and Object.constants.include?(classname)
-      warn("created definition re-opens an existing toplevel class: #{classname}")
-    end
+    parentmodule = mapped_class_name(qname, mpath)
+    parse_elements(c, typedef.elements, qname.namespace, parentmodule, true)
+    c
   end
 
   def sort_dependency(types)
@@ -399,6 +418,14 @@ private
     dep.delete(type.name)
     result
   end
+
+  def modulepath_split(modulepath)
+    if modulepath.is_a?(::Array)
+      modulepath
+    else
+      modulepath.to_s.split('::')
+    end
+  end
 end