soap4r 1.5.7 → 1.5.8

data/lib/wsdl/soap/mappingRegistryCreator.rb

@@ -22,14 +22,16 @@ class MappingRegistryCreator
 
   attr_reader :definitions
 
-  def initialize(definitions, modulepath = nil)
+  def initialize(definitions, name_creator, modulepath = nil)
     @definitions = definitions
+    @name_creator = name_creator
     @modulepath = modulepath
   end
 
   def dump
-    encoded_creator = EncodedMappingRegistryCreator.new(@definitions, @modulepath)
-    literal_creator = LiteralMappingRegistryCreator.new(@definitions, @modulepath)
+    defined_const = {}
+    encoded_creator = EncodedMappingRegistryCreator.new(@definitions, @name_creator, @modulepath, defined_const)
+    literal_creator = LiteralMappingRegistryCreator.new(@definitions, @name_creator, @modulepath, defined_const)
     wsdl_name = @definitions.name ? @definitions.name.name : 'default'
     module_name = safeconstname(wsdl_name + 'MappingRegistry')
     if @modulepath
@@ -43,6 +45,10 @@ class MappingRegistryCreator
     varname = 'LiteralRegistry'
     m.def_const(varname, '::SOAP::Mapping::LiteralRegistry.new')
     m.def_code(literal_creator.dump(varname))
+    #
+    defined_const.each do |ns, tag|
+      m.def_const(tag, dq(ns))
+    end
     m.dump
   end
 end

data/lib/wsdl/soap/mappingRegistryCreatorSupport.rb

@@ -13,10 +13,76 @@ module WSDL
 module SOAP
 
 
+# requires @defined_const = {}, @dump_with_inner, @modulepath
 module MappingRegistryCreatorSupport
   include ClassDefCreatorSupport
   include XSD::CodeGen
 
+  def dump_with_inner
+    @dump_with_inner = []
+    @dump_with_inner.unshift(yield)
+    @dump_with_inner.join("\n")
+  end
+
+  def dump_complextypedef(mpath, qname, typedef, as_element = nil, opt = {})
+    case typedef.compoundtype
+    when :TYPE_STRUCT, :TYPE_EMPTY
+      dump_complex_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_ARRAY
+      dump_array_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_SIMPLE
+      dump_simple_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_MAP
+      # mapped as a general Hash
+      nil
+    else
+      raise RuntimeError.new(
+        "unknown kind of complexContent: #{typedef.compoundtype}")
+    end
+  end
+
+  def dump_array_typemap(mpath, qname, typedef, as_element, opt)
+    if typedef.find_soapenc_arytype
+      if opt[:encoded]
+        dump_encoded_array_typemap(mpath, qname, typedef, as_element, opt)
+      end
+    else
+      dump_literal_array_typemap(mpath, qname, typedef, as_element, opt)
+    end
+  end
+
+  def dump_complex_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    if var[:schema_type] and typedef.base
+      var[:schema_basetype] = typedef.base
+    end
+    parentmodule = var[:class]
+    parsed_element =
+      parse_elements(typedef.elements, qname.namespace, parentmodule, opt)
+    if typedef.choice?
+      parsed_element.unshift(:choice)
+    end
+    var[:schema_element] = dump_schema_element_definition(parsed_element, 2)
+    unless typedef.attributes.empty?
+      var[:schema_attribute] = define_attribute(typedef.attributes)
+    end
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_simple_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    unless typedef.attributes.empty?
+      var[:schema_attribute] = define_attribute(typedef.attributes)
+    end
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
   def dump_schema_element_definition(definition, indent = 0)
     return '[]' if definition.empty?
     sp = ' ' * indent
@@ -47,6 +113,7 @@ module MappingRegistryCreatorSupport
 
   def dump_type(name, type)
     if name
+      assign_const(name.namespace, 'Ns')
       '[' + ndq(type) + ', ' + dqname(name) + ']'
     else
       ndq(type)
@@ -61,7 +128,7 @@ module MappingRegistryCreatorSupport
     end
   end
 
-  def parse_elements(elements, base_namespace)
+  def parse_elements(elements, base_namespace, mpath, opt)
     schema_element = []
     any = false
     elements.each do |element|
@@ -76,32 +143,22 @@ module MappingRegistryCreatorSupport
         occurrence = nil
         schema_element << [varname, eleqname, type, occurrence]
       when XMLSchema::Element
-        if element.type == XSD::AnyTypeName
-          type = nil
-        elsif @simpletypes[element.type]
-          type = create_class_name(element.type, @modulepath)
-        elsif klass = element_basetype(element)
-          type = klass.name
-        elsif element.type
-          type = create_class_name(element.type, @modulepath)
-        elsif element.ref
-          next if element.ref == SchemaName
-          type = create_class_name(element.ref, @modulepath)
-        else
-          type = nil      # means anyType.
-          # do we define a class for local complexType from it's name?
-          #   type = create_class_name(element.name, @modulepath)
-          # <element>
-          #   <complexType>
-          #     <seq...>
-          #   </complexType>
-          # </element>
+        next if element.ref == SchemaName
+        typebase = @modulepath
+        if element.anonymous_type?
+          child_opt = {
+            :qualified => (element.elementform == 'qualified'),
+            :is_anonymous => true
+          }
+          @dump_with_inner << dump_complextypedef(mpath, element.name, element.local_complextype, nil, child_opt)
+          typebase = mpath
         end
+        type = create_type_name(typebase, element)
         name = name_element(element).name
         varname = safevarname(name)
         if element.map_as_array?
           if type
-            type << '[]'
+            type += '[]'
           else
             type = '[]'
           end
@@ -114,12 +171,25 @@ module MappingRegistryCreatorSupport
         occurrence = [element.minoccurs, element.maxoccurs]
         schema_element << [varname, eleqname, type, occurrence]
       when WSDL::XMLSchema::Sequence
-        child_schema_element = parse_elements(element.elements, base_namespace)
+        child_schema_element =
+          parse_elements(element.elements, base_namespace, mpath, opt)
         schema_element << child_schema_element
       when WSDL::XMLSchema::Choice
-        child_schema_element = parse_elements(element.elements, base_namespace)
-        child_schema_element.unshift(:choice)
+        child_schema_element =
+          parse_elements(element.elements, base_namespace, mpath, opt)
+        if !element.map_as_array?
+          # choice + maxOccurs="unbounded" is treated just as 'all' now.
+          child_schema_element.unshift(:choice)
+        end
         schema_element << child_schema_element
+      when WSDL::XMLSchema::Group
+        if element.content.nil?
+          warn("no group definition found: #{element}")
+          next
+        end
+        child_schema_element =
+          parse_elements(element.content.elements, base_namespace, mpath, opt)
+        schema_element.concat(child_schema_element)
       else
         raise RuntimeError.new("unknown type: #{element}")
       end
@@ -127,35 +197,6 @@ module MappingRegistryCreatorSupport
     schema_element
   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(attributes)
     schema_attribute = []
     attributes.each do |attribute|
@@ -170,31 +211,21 @@ module MappingRegistryCreatorSupport
     end
     "{\n    " +
       schema_attribute.collect { |name, type|
+        assign_const(name.namespace, 'Ns')
         dqname(name) + ' => ' + ndq(type)
       }.join(",\n    ") +
     "\n  }"
   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_entry(regname, var)
     "#{regname}.register(\n  " +
       [
         dump_entry_item(var, :class),
         dump_entry_item(var, :soap_class),
-        dump_entry_item(var, :schema_ns, true),
-        dump_entry_item(var, :schema_name, true),
-        dump_entry_item(var, :schema_type, true),
+        dump_entry_item(var, :schema_name, :qname),
+        dump_entry_item(var, :schema_type, :qname),
+        dump_entry_item(var, :is_anonymous),
+        dump_entry_item(var, :schema_basetype, :qname),
         dump_entry_item(var, :schema_qualified),
         dump_entry_item(var, :schema_element),
         dump_entry_item(var, :schema_attribute)
@@ -202,58 +233,142 @@ module MappingRegistryCreatorSupport
     "\n)\n"
   end
 
-  def dump_entry_item(var, key, as_string = false)
+  def dump_entry_item(var, key, dump_type = :none)
     if var.key?(key)
-      if as_string
-        ":#{key} => #{ndq(var[key])}"
-      else
+      case dump_type
+      when :none
         ":#{key} => #{var[key]}"
+      when :string
+        if @defined_const.key?(var[key])
+          ":#{key} => #{@defined_const[var[key]]}"
+        else
+          ":#{key} => #{ndq(var[key])}"
+        end
+      when :qname
+        qname = var[key]
+        if @defined_const.key?(qname.namespace)
+          ns = @defined_const[qname.namespace]
+        else
+          ns = ndq(qname.namespace)
+        end
+        ":#{key} => XSD::QName.new(#{ns}, #{ndq(qname.name)})"
+      else
+        raise "Unknown dump type: #{dump_type}"
       end
-    else
-      nil
     end
   end
 
-  def dump_simpletypedef(qname, simpletype, as_element = nil, qualified = false)
+  def dump_simpletypedef(mpath, qname, simpletype, as_element = nil, opt = {})
     if simpletype.restriction
-      dump_simpletypedef_restriction(qname, simpletype, as_element, qualified)
+      dump_simpletypedef_restriction(mpath, qname, simpletype, as_element, opt)
     elsif simpletype.list
-      dump_simpletypedef_list(qname, simpletype, as_element, qualified)
+      dump_simpletypedef_list(mpath, qname, simpletype, as_element, opt)
     elsif simpletype.union
-      dump_simpletypedef_union(qname, simpletype, as_element, qualified)
+      dump_simpletypedef_union(mpath, qname, simpletype, as_element, opt)
     else
       raise RuntimeError.new("unknown kind of simpletype: #{simpletype}")
     end
   end
 
-  def dump_simpletypedef_restriction(qname, typedef, as_element, qualified)
+  def dump_simpletypedef_restriction(mpath, qname, typedef, as_element, opt)
     restriction = typedef.restriction
-    if restriction.enumeration.empty?
+    unless restriction.enumeration?
       # not supported.  minlength?
       return nil
     end
     var = {}
-    var[:class] = create_class_name(qname, @modulepath)
-    if as_element
-      var[:schema_type] = nil
-      var[:schema_ns] = as_element.namespace
-    elsif typedef.name.nil?
-      var[:schema_type] = nil
-      var[:schema_ns] = qname.namespace
-    else
-      var[:schema_type] = qname.name
-      var[:schema_ns] = qname.namespace
-    end
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    assign_const(schema_ns, 'Ns')
     dump_entry(@varname, var)
   end
 
-  def dump_simpletypedef_list(qname, typedef, as_element, qualified)
+  def dump_simpletypedef_list(mpath, qname, typedef, as_element, opt)
     nil
   end
 
-  def dump_simpletypedef_union(qname, typedef, as_element, qualified)
+  def dump_simpletypedef_union(mpath, qname, typedef, as_element, opt)
     nil
   end
+
+  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item')
+
+  def dump_literal_array_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    parsed_element =
+      parse_elements(typedef.elements, qname.namespace, var[:class], opt)
+    if parsed_element.empty?
+      parsed_element = [create_array_element_definition(typedef, mpath)]
+    end
+    var[:schema_element] = dump_schema_element_definition(parsed_element, 2)
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_encoded_array_typemap(mpath, qname, typedef, as_element, opt)
+    arytype = typedef.find_arytype || XSD::AnyTypeName
+    type = XSD::QName.new(arytype.namespace, arytype.name.sub(/\[(?:,)*\]$/, ''))
+    return <<__EOD__
+#{@varname}.set(
+  #{mapped_class_name(qname, mpath)},
+  ::SOAP::SOAPArray,
+  ::SOAP::Mapping::EncodedRegistry::TypedArrayFactory,
+  { :type => #{dqname(type)} }
+)
+__EOD__
+  end
+
+  # used when "soapenc:arrayType" definition
+  def create_array_element_definition(typedef, mpath)
+    child_type = typedef.child_type
+    child_element = typedef.find_aryelement
+    if child_type == XSD::AnyTypeName
+      type = nil
+    elsif child_element
+      if klass = element_basetype(child_element)
+        type = klass.name
+      else
+        typename = child_element.type || child_element.name
+        type = mapped_class_name(typename, mpath)
+      end
+    elsif child_type
+      type = mapped_class_name(child_type, mpath)
+    else
+      type = nil
+    end
+    occurrence = [0, nil]
+    if child_element and child_element.name
+      if child_element.map_as_array?
+        type << '[]' if type
+        occurrence = [child_element.minoccurs, child_element.maxoccurs]
+      end
+      child_element_name = child_element.name
+    else
+      child_element_name = DEFAULT_ITEM_NAME
+    end
+    [child_element_name.name, child_element_name, type, occurrence]
+  end
+
+  def define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    var[:class] = mapped_class_name(qname, mpath)
+    if as_element
+      var[:schema_name] = as_element
+      schema_ns = as_element.namespace
+    elsif typedef.name.nil?
+      var[:schema_name] = qname
+      schema_ns = qname.namespace
+    else
+      var[:schema_type] = qname
+      schema_ns = qname.namespace
+    end
+    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous)
+    # true, false, or nil
+    if opt.key?(:qualified)
+      var[:schema_qualified] = opt[:qualified].to_s
+    end
+  end
 end
 
 

data/lib/wsdl/soap/methodDefCreator.rb

@@ -20,8 +20,9 @@ class MethodDefCreator
 
   attr_reader :definitions
 
-  def initialize(definitions, modulepath)
+  def initialize(definitions, name_creator, modulepath, defined_const)
     @definitions = definitions
+    @name_creator = name_creator
     @modulepath = modulepath
     @simpletypes = @definitions.collect_simpletypes
     @complextypes = @definitions.collect_complextypes
@@ -29,15 +30,16 @@ class MethodDefCreator
     @types = []
     @encoded = false
     @literal = false
+    @defined_const = defined_const
   end
 
-  def dump(porttype)
+  def dump(name)
     @types.clear
     @encoded = false
     @literal = false
     methoddef = ""
-    port = @definitions.porttype(porttype)
-    binding = port.find_binding
+    porttype = @definitions.porttype(name)
+    binding = porttype.find_binding
     if binding
       binding.operations.each do |op_bind|
         next unless op_bind # no binding is defined
@@ -96,7 +98,8 @@ private
     binding.fault.each do |fault|
       op_fault = {}
       soapfault = fault.soapfault
-      faultclass = create_class_name(fault.name, @modulepath)
+      next if soapfault.nil?
+      faultclass = mapped_class_name(fault.name, @modulepath)
       op_fault[:ns] = fault.name.namespace
       op_fault[:name] = fault.name.name
       op_fault[:namespace] = soapfault.namespace
@@ -138,8 +141,9 @@ __EOD__
       @literal = true
     end
     if style == :rpc
+      assign_const(qname.namespace, 'Ns')
       return <<__EOD__
-[ #{qname.dump},
+[ #{dqname(qname)},
   #{definitions}]
 __EOD__
     else
@@ -158,16 +162,8 @@ __EOD__
       [nil, part.element.namespace, part.element.name]
     elsif definedtype = @complextypes[part.type]
       case definedtype.compoundtype
-      when :TYPE_STRUCT, :TYPE_EMPTY    # ToDo: empty should be treated as void.
-        type = create_class_name(part.type, @modulepath)
-	[type, part.type.namespace, part.type.name]
-      when :TYPE_ARRAY
-	arytype = definedtype.find_arytype || XSD::AnyTypeName
-	arytypename = arytype.name.sub(/\[(?:,)*\]$/, '')
-        arytypedef = create_class_name(XSD::QName.new(nil, arytypename), @modulepath)
-	[arytypedef + '[]', part.type.namespace, part.type.name]
-      when :TYPE_SIMPLE
-        type = create_class_name(part.type, @modulepath)
+      when :TYPE_STRUCT, :TYPE_EMPTY, :TYPE_ARRAY, :TYPE_SIMPLE
+        type = mapped_class_name(part.type, @modulepath)
 	[type, part.type.namespace, part.type.name]
       when :TYPE_MAP
 	[Hash.name, part.type.namespace, part.type.name]