soap4r 1.5.5.20061022 → 1.5.6

data/lib/soap/mapping/factory.rb

@@ -1,5 +1,5 @@
 # SOAP4R - Mapping factory.
-# Copyright (C) 2000-2003, 2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  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;
@@ -63,7 +63,7 @@ private
         value = child
       else
         klass = Mapping.class_from_name(eledef.type)
-        if klass && klass.ancestors.include?(::SOAP::SOAPBasetype)
+        if klass && klass.include?(::SOAP::SOAPBasetype)
           value = klass.new(child)
         else
           # should check klass matches an actual object?

data/lib/soap/mapping/literalregistry.rb

@@ -1,5 +1,5 @@
 # SOAP4R - literal mapping registry.
-# Copyright (C) 2004-2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  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;
@@ -48,9 +48,8 @@ class LiteralRegistry
 
   # node should be a SOAPElement
   def soap2obj(node, obj_class = nil)
-    # obj_class is given when rpc/literal service.  but ignored for now.
     begin
-      return any2obj(node)
+      return any2obj(node, obj_class)
     rescue MappingError
     end
     if @excn_handler_soap2obj
@@ -70,17 +69,30 @@ private
 
   def any2soap(obj, qname)
     ele = nil
-    if definition = schema_definition_from_class(obj.class)
-      ele = stubobj2soap(obj, qname, definition)
-    elsif obj.is_a?(SOAP::Mapping::Object)
+    if obj.is_a?(SOAP::Mapping::Object)
       ele = mappingobj2soap(obj, qname)
-    elsif obj.is_a?(Hash)
-      ele = SOAPElement.from_obj(obj)
+    elsif definition = schema_definition_from_class(obj.class)
+      # search with class first.  obj can be an instance of a subclass of
+      # defined class.
+      ele = stubobj2soap(obj, qname, definition)
+    elsif definition = schema_definition_from_elename(qname)
+      ele = stubobj2soap(obj, qname, definition)
+    else
+      ele = anyobj2soap(obj, qname)
+    end
+    ele
+  end
+
+  def anyobj2soap(obj, qname)
+    ele = nil
+    case obj
+    when Hash
+      ele = SOAPElement.from_obj(obj, nil)
       ele.elename = qname
-    elsif obj.is_a?(Array)
+    when Array
       # treat as a list of simpletype
       ele = SOAPElement.new(qname, obj.join(" "))
-    elsif obj.is_a?(XSD::QName)
+    when XSD::QName
       ele = SOAPElement.new(qname)
       ele.text = obj
     else
@@ -107,41 +119,58 @@ private
     if definition.type
       ele.extraattr[XSD::AttrTypeName] = definition.type
     end
-    any = nil
-    if definition.have_any?
-      any = Mapping.get_attributes_for_any(obj, definition.elements)
-    end
-    definition.elements.each do |eledef|
-      if eledef.elename == XSD::AnyTypeName
-        if any
-          SOAPElement.from_objs(any).each do |child|
-            ele.add(child)
-          end
-        end
-      elsif child = Mapping.get_attribute(obj, eledef.varname)
-        if eledef.as_array?
-          child.each do |item|
-            ele.add(obj2soap(item, eledef.elename))
-          end
-        else
-          ele.add(obj2soap(child, eledef.elename))
-        end
-      elsif obj.respond_to?(:each) and eledef.as_array?
-        obj.each do |item|
-          ele.add(obj2soap(item, eledef.elename))
-        end
-      end
-    end
+    stubobj2soap_elements(obj, ele, definition.elements)
     if definition.attributes
       definition.attributes.each do |qname, param|
-        at = obj.__send__(
-          XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name))
+        at = Mapping.get_attribute(obj, XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name))
         ele.extraattr[qname] = at
       end
     end
     ele
   end
 
+  def stubobj2soap_elements(obj, ele, definition, is_choice = false)
+    added = false
+    case definition
+    when SchemaSequenceDefinition, SchemaEmptyDefinition
+      definition.each do |eledef|
+        ele_added = stubobj2soap_elements(obj, ele, eledef, is_choice)
+        added = true if ele_added
+      end
+    when SchemaChoiceDefinition
+      definition.each do |eledef|
+        added = stubobj2soap_elements(obj, ele, eledef, true)
+        break if added
+      end
+    else
+      added = true
+      if definition.as_any?
+        any = Mapping.get_attributes_for_any(obj)
+        SOAPElement.from_objs(any).each do |child|
+          ele.add(child)
+        end
+      elsif obj.respond_to?(:each) and definition.as_array?
+        obj.each do |item|
+          ele.add(obj2soap(item, definition.elename))
+        end
+      else
+        child = Mapping.get_attribute(obj, definition.varname)
+        if child.nil? and (is_choice or definition.minoccurs == 0)
+          added = false
+        else
+          if child.respond_to?(:each) and definition.as_array?
+            child.each do |item|
+              ele.add(obj2soap(item, definition.elename))
+            end
+          else
+            ele.add(obj2soap(child, definition.elename))
+          end
+        end
+      end
+    end
+    added
+  end
+
   def mappingobj2soap(obj, qname)
     ele = SOAPElement.new(qname)
     obj.__xmlele.each do |key, value|
@@ -153,23 +182,29 @@ private
         ele.add(obj2soap(value, key))
       end
     end
+    add_attributes2soap(obj, ele)
     ele
   end
 
   def any2obj(node, obj_class = nil)
+    is_compound = node.is_a?(::SOAP::SOAPCompoundtype)
+    # trust xsi:type first
+    if is_compound and node.type
+      definition = schema_definition_from_type(node.type)
+    end
+    # element name next
+    definition ||= schema_definition_from_elename(node.elename)
+    # class defined in parent type last
     if obj_class
-      definition = schema_definition_from_class(obj_class)
-    else
-      definition = schema_definition_from_elename(node.elename)
-      if definition
-        obj_class = definition.class_for
-      end
+      definition ||= schema_definition_from_class(obj_class)
     end
-    if node.is_a?(::SOAP::SOAPElement) or node.is_a?(::SOAP::SOAPStruct)
+    if definition
+      obj_class = definition.class_for
+    end
+    if is_compound
       if definition
         return elesoap2stubobj(node, obj_class, definition)
       else
-        # SOAPArray for literal?
         return elesoap2plainobj(node)
       end
     end
@@ -179,15 +214,25 @@ private
   end
 
   def elesoap2stubobj(node, obj_class, definition)
-    obj = Mapping.create_empty_object(obj_class)
-    add_elesoap2stubobj(node, obj, definition)
+    obj = nil
+    if obj_class < ::String
+      obj = node.text
+    else
+      obj = Mapping.create_empty_object(obj_class)
+      add_elesoap2stubobj(node, obj, definition)
+    end
     add_attributes2stubobj(node, obj, definition)
     obj
   end
 
   def elesoap2plainobj(node)
-    obj = anytype2obj(node)
-    add_elesoap2plainobj(node, obj)
+    obj = nil
+    if node.members.empty?
+      obj = base2obj(node, ::SOAP::SOAPString)
+    else
+      obj = anytype2obj(node)
+      add_elesoap2plainobj(node, obj)
+    end
     add_attributes2obj(node, obj)
     obj
   end
@@ -204,9 +249,7 @@ private
   def add_elesoap2stubobj(node, obj, definition)
     vars = {}
     node.each do |name, value|
-      item = definition.elements.find { |k, v|
-        k.elename == value.elename
-      }
+      item = definition.elements.find_element(value.elename)
       if item
         child = elesoapchild2obj(value, item)
       else
@@ -221,7 +264,7 @@ private
         vars[name] = child
       end
     end
-    if obj.is_a?(::Array) and vars.keys.size == 1
+    if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
       obj.replace(vars.values[0])
     else
       Mapping.set_attributes(obj, vars)
@@ -229,23 +272,20 @@ private
   end
 
   def elesoapchild2obj(value, eledef)
-    child_definition = schema_definition_from_elename(eledef.elename)
-    if child_definition
-      any2obj(value, child_definition.class_for)
-    elsif eledef.mapped_class
-      child_definition = schema_definition_from_class(eledef.mapped_class)
+    if eledef.mapped_class
+      if eledef.mapped_class.include?(::SOAP::SOAPBasetype)
+        base2obj(value, eledef.mapped_class)
+      else
+        any2obj(value, eledef.mapped_class)
+      end
+    else
+      child_definition = schema_definition_from_elename(eledef.elename)
       if child_definition
         any2obj(value, child_definition.class_for)
       else
-        if eledef.mapped_class.ancestors.include?(::SOAP::SOAPBasetype)
-          base2obj(value, eledef.mapped_class)
-        else
-          any2obj(value, eledef.mapped_class)
-        end
+        # untyped element is treated as anyType.
+        any2obj(value)
       end
-    else
-      # untyped element is treated as anyType.
-      any2obj(value)
     end
   end
 
@@ -259,7 +299,7 @@ private
         child = attr
         if class_name
           klass = Mapping.class_from_name(class_name)
-          if klass.ancestors.include?(::SOAP::SOAPBasetype)
+          if klass.include?(::SOAP::SOAPBasetype)
             child = klass.new(attr).data
           end
         end

data/lib/soap/mapping/mapping.rb

@@ -1,5 +1,5 @@
 # SOAP4R - Ruby type mapping utility.
-# Copyright (C) 2000, 2001, 2003-2006  NAKAMURA Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  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;
@@ -7,6 +7,7 @@
 
 
 require 'xsd/codegen/gensupport'
+require 'soap/mapping/schemadefinition'
 
 
 module SOAP
@@ -44,6 +45,19 @@ module Mapping
     soap_obj
   end
 
+  def self.objs2soap(objs, registry = nil, types = nil, opt = EMPTY_OPT)
+    registry ||= Mapping::DefaultRegistry
+    ary = []
+    protect_mapping(opt) do
+      0.upto(objs.length - 1) do |idx|
+        type = types ? types[idx] : nil
+        soap = _obj2soap(objs[idx], registry, type)
+        ary << soap
+      end
+    end
+    ary
+  end
+
   def self.soap2obj(node, registry = nil, klass = nil, opt = EMPTY_OPT)
     registry ||= Mapping::DefaultRegistry
     obj = nil
@@ -106,7 +120,11 @@ module Mapping
   end
 
   def self._obj2soap(obj, registry, type = nil)
-    if referent = Thread.current[:SOAPMapping][:MarshalKey][obj.__id__] and
+    if obj.respond_to?(:to_xmlpart)
+      SOAPRawData.new(obj)
+    elsif defined?(::REXML) and obj.is_a?(::REXML::Element)
+      SOAPRawData.new(SOAPREXMLElementWrap.new(obj))
+    elsif referent = Thread.current[:SOAPMapping][:MarshalKey][obj.__id__] and
         !Thread.current[:SOAPMapping][:NoReference]
       SOAPReference.new(referent)
     elsif registry
@@ -186,16 +204,18 @@ module Mapping
   def self.const_from_name(name, lenient = false)
     const = ::Object
     name.sub(/\A::/, '').split('::').each do |const_str|
-      if XSD::CodeGen::GenSupport.safeconstname?(const_str)
+      begin
         if const.const_defined?(const_str)
           const = const.const_get(const_str)
           next
         end
-      elsif lenient
-        const_str = XSD::CodeGen::GenSupport.safeconstname(const_str)
-        if const.const_defined?(const_str)
-          const = const.const_get(const_str)
-          next
+      rescue NameError
+        if lenient
+          const_str = XSD::CodeGen::GenSupport.safeconstname(const_str)
+          if const.const_defined?(const_str)
+            const = const.const_get(const_str)
+            next
+          end
         end
       end
       return nil
@@ -269,20 +289,12 @@ module Mapping
     end
   end
 
-  def self.get_attributes_for_any(obj, elements)
+  EMPTY_ATTRIBUTES = {}.freeze
+  def self.get_attributes_for_any(obj)
     if obj.respond_to?(:__xmlele_any)
-      obj.__xmlele_any
+      obj.__xmlele_any || EMPTY_ATTRIBUTES
     else
-      any = get_attributes(obj)
-      if elements
-        elements.each do |child_ele|
-          child = get_attribute(obj, child_ele.name.name)
-          if k = any.key(child)
-            any.delete(k)
-          end
-        end
-      end
-      any
+      get_attributes(obj)
     end
   end
 
@@ -293,6 +305,9 @@ module Mapping
     when ::Hash
       return obj[attr_name] || obj[attr_name.intern]
     else
+      if obj.respond_to?(attr_name)
+        return obj.__send__(attr_name)
+      end
       iv = obj.instance_variables
       name = XSD::CodeGen::GenSupport.safevarname(attr_name)
       if iv.include?("@#{name}")
@@ -300,12 +315,8 @@ module Mapping
       elsif iv.include?("@#{attr_name}")
         return obj.instance_variable_get("@#{attr_name}")
       end
-      if obj.is_a?(::Struct) or obj.is_a?(Marshallable)
-        if obj.respond_to?(name)
-          return obj.__send__(name)
-        elsif obj.respond_to?(attr_name)
-          return obj.__send__(attr_name)
-        end
+      if obj.respond_to?(name)
+        return obj.__send__(name)
       end
       nil
     end
@@ -374,8 +385,8 @@ module Mapping
   end
 
   def self.schema_definition_classdef(klass)
-    if definition = Thread.current[:SOAPMapping][:SchemaDefinition][klass]
-      return definition
+    if Thread.current[:SOAPMapping][:SchemaDefinition].key?(klass)
+      return Thread.current[:SOAPMapping][:SchemaDefinition][klass]
     end
     ns = schema_ns_definition(klass)
     name = schema_name_definition(klass)
@@ -410,24 +421,52 @@ module Mapping
     if schema_element
       if schema_element.respond_to?(:is_concrete_definition) and
           schema_element.is_concrete_definition
-        definition.elements.replace(schema_element)
+        definition.elements = schema_element
       else
-        parse_schema_element_definition(klass, definition, schema_element)
+        default_ns = elename.namespace if elename
+        default_ns ||= type.namespace if type
+        definition.elements = parse_schema_definition(schema_element, default_ns)
+        if klass < ::Array
+          definition.elements.set_array
+        end
       end
     end
     definition
   end
 
   # for backward compatibility
-  def self.parse_schema_element_definition(klass, definition, schema_element)
+  # returns SchemaComplexTypeDefinition
+  def self.parse_schema_definition(schema_element, default_ns)
+    definition = nil
     if schema_element[0] == :choice
       schema_element.shift
-      definition.set_choice
+      definition = SchemaChoiceDefinition.new
+    else
+      definition = SchemaSequenceDefinition.new
+    end
+    schema_element.each do |ele|
+      element_definition = parse_schema_element_definition(ele, default_ns)
+      definition << element_definition
     end
-    schema_element.each do |element|
-      varname, info = element
+    definition
+  end
+
+  # returns SchemaElementDefinition
+  def self.parse_schema_element_definition(schema_element, default_ns)
+    if schema_element[0] == :choice
+      parse_schema_definition(schema_element, default_ns)
+    elsif schema_element[0].is_a?(Array)
+      parse_schema_definition(schema_element, default_ns)
+    else
+      varname, info, occurrence = schema_element
       mapped_class_str, elename = info
-      as_array = klass.ancestors.include?(::Array)
+      if occurrence
+        minoccurs, maxoccurs = occurrence
+      else
+        # for backward compatibility
+        minoccurs, maxoccurs = 1, 1
+      end
+      as_any = as_array = false
       if /\[\]$/ =~ mapped_class_str
         mapped_class_str = mapped_class_str.sub(/\[\]$/, '')
         if mapped_class_str.empty?
@@ -442,77 +481,32 @@ module Mapping
         end
       end
       if elename == XSD::AnyTypeName
-        definition.set_any
+        as_any = true
       elsif elename.nil?
-        ns ||= definition.elename.namespace if definition.elename
-        ns ||= definition.type.namespace if definition.type
-        elename = XSD::QName.new(ns, varname)
+        elename = XSD::QName.new(default_ns, varname)
       end
-      definition.elements <<
-        SchemaElementDefinition.new(varname, mapped_class, elename, as_array)
-    end
-  end
-
-  class SchemaElementDefinition
-    attr_reader :varname, :mapped_class, :elename
-
-    def initialize(varname, mapped_class, elename, as_array)
-      @varname = varname
-      @mapped_class = mapped_class
-      @elename = elename
-      @as_array = as_array
-    end
-
-    def as_array?
-      @as_array
-    end
-
-    def is_concrete_definition
-      true
-    end
-  end
-
-  class SchemaElementChoiceDefinition < ::Array
-    def is_concrete_definition
-      true
+      SchemaElementDefinition.new(
+        varname, mapped_class, elename, minoccurs, maxoccurs, as_any, as_array)
     end
   end
 
-  class SchemaDefinition
-    attr_reader :class_for
-    attr_reader :elename, :type
-    attr_reader :qualified, :elements
-    attr_accessor :attributes
-
-    def initialize(class_for, elename, type, qualified)
-      @class_for = class_for
-      @elename = elename
-      @type = type
-      @qualified = qualified
-      @elements = []
-      @attributes = nil
-      @choice = false
-      @any = false
-    end
-
-    def choice?
-      @choice
-    end
-
-    def have_any?
-      @any
-    end
-
-    def set_choice
-      @choice = true
-    end
+  class << Mapping
+  public
 
-    def set_any
-      @any = true
+    def protect_threadvars(*symbols)
+      backup = {}
+      begin
+        symbols.each do |sym|
+          backup[sym] = Thread.current[sym]
+        end
+        yield
+      ensure
+        symbols.each do |sym|
+          Thread.current[sym] = backup[sym]
+        end
+      end
     end
-  end
 
-  class << Mapping
   private
 
     def class_schema_variable(sym, klass)
@@ -531,20 +525,6 @@ module Mapping
       end
     end
 
-    def protect_threadvars(*symbols)
-      backup = {}
-      begin
-        symbols.each do |sym|
-          backup[sym] = Thread.current[sym]
-        end
-        yield
-      ensure
-        symbols.each do |sym|
-          Thread.current[sym] = backup[sym]
-        end
-      end
-    end
-
     def add_md_ary(md_ary, ary, indices, registry)
       for idx in 0..(ary.size - 1)
         if ary[idx].is_a?(Array)