soap4r 1.5.7 → 1.5.8

data/lib/soap/mapping/encodedregistry.rb

@@ -65,12 +65,9 @@ class EncodedRegistry
           return ret if ret
         end
       end
-      ancestors = klass.ancestors
-      ancestors.delete(klass)
-      ancestors.delete(::Object)
-      ancestors.delete(::Kernel)
-      ancestors.each do |klass|
-        if map = @obj2soap[klass]
+      klass.ancestors.each do |baseclass|
+        next if baseclass == klass
+        if map = @obj2soap[baseclass]
           map.each do |soap_class, factory, info|
             if info[:derived_class]
               ret = factory.obj2soap(soap_class, obj, info, @registry)
@@ -126,6 +123,7 @@ class EncodedRegistry
 
   StringFactory = StringFactory_.new
   BasetypeFactory = BasetypeFactory_.new
+  FixnumFactory = FixnumFactory_.new
   DateTimeFactory = DateTimeFactory_.new
   ArrayFactory = ArrayFactory_.new
   Base64Factory = Base64Factory_.new
@@ -149,6 +147,7 @@ class EncodedRegistry
       {:derived_class => true}],
     [::Float,        ::SOAP::SOAPFloat,      BasetypeFactory,
       {:derived_class => true}],
+    [::Fixnum,       ::SOAP::SOAPInt,        FixnumFactory],
     [::Integer,      ::SOAP::SOAPInt,        BasetypeFactory,
       {:derived_class => true}],
     [::Integer,      ::SOAP::SOAPLong,       BasetypeFactory,
@@ -188,8 +187,10 @@ class EncodedRegistry
     [::String,       ::SOAP::SOAPGMonth,     BasetypeFactory],
     [::String,       ::SOAP::SOAPQName,      BasetypeFactory],
 
-    [::Hash,         ::SOAP::SOAPArray,      HashFactory],
-    [::Hash,         ::SOAP::SOAPStruct,     HashFactory],
+    [::Hash,         ::SOAP::SOAPArray,      HashFactory,
+      {:derived_class => true}],
+    [::Hash,         ::SOAP::SOAPStruct,     HashFactory,
+      {:derived_class => true}],
 
     [::Array,        ::SOAP::SOAPArray,      ArrayFactory,
       {:derived_class => true}],
@@ -212,6 +213,7 @@ class EncodedRegistry
       {:derived_class => true}],
     [::Float,        ::SOAP::SOAPFloat,      BasetypeFactory,
       {:derived_class => true}],
+    [::Fixnum,       ::SOAP::SOAPInt,        FixnumFactory],
     [::Integer,      ::SOAP::SOAPInt,        BasetypeFactory,
       {:derived_class => true}],
     [::Integer,      ::SOAP::SOAPLong,       BasetypeFactory,
@@ -324,7 +326,7 @@ private
 
   def _obj2soap(obj, type_qname = nil)
     ret = nil
-    if obj.is_a?(SOAPStruct) or obj.is_a?(SOAPArray)
+    if obj.is_a?(SOAPCompoundtype)
       obj.replace do |ele|
         Mapping._obj2soap(ele, self)
       end
@@ -334,6 +336,7 @@ private
     elsif type_qname && type = TypeMap[type_qname]
       return base2soap(obj, type)
     end
+    cause = nil
     begin 
       if definition = schema_definition_from_class(obj.class)
         return stubobj2soap(obj, definition)
@@ -342,6 +345,7 @@ private
         @default_factory.obj2soap(nil, obj, nil, self)
       return ret if ret
     rescue MappingError
+      cause = $!
     end
     if @excn_handler_obj2soap
       ret = @excn_handler_obj2soap.call(obj) { |yield_obj|
@@ -349,7 +353,7 @@ private
       }
       return ret if ret
     end
-    raise MappingError.new("Cannot map #{ obj.class.name } to SOAP/OM.")
+    raise MappingError.new("Cannot map #{ obj.class.name } to SOAP/OM.", cause)
   end
 
   # Might return nil as a mapping result.
@@ -365,7 +369,7 @@ private
     else
       klass = definition.class_for if definition
     end
-    if definition and node.is_a?(::SOAP::SOAPStruct)
+    if definition and node.is_a?(::SOAP::SOAPNameAccessible)
       return elesoap2stubobj(node, klass, definition)
     end
     if node.extraattr.key?(RubyTypeName)
@@ -376,15 +380,17 @@ private
     return obj if conv
     conv, obj = @default_factory.soap2obj(nil, node, nil, self)
     return obj if conv
+    cause = nil
     if @excn_handler_soap2obj
       begin
         return @excn_handler_soap2obj.call(node) { |yield_node|
 	    Mapping._soap2obj(yield_node, self)
 	  }
       rescue Exception
+        cause = $!
       end
     end
-    raise MappingError.new("Cannot map #{ node.type.name } to Ruby object.")
+    raise MappingError.new("Cannot map #{ node.type.name } to Ruby object.", cause)
   end
 
   def addiv2obj(obj, attr)
@@ -513,7 +519,7 @@ private
       end
     end
     if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
-      obj.replace(vars.values[0])
+      Array.instance_method(:replace).bind(obj).call(vars.values[0])
     else
       Mapping.set_attributes(obj, vars)
     end

data/lib/soap/mapping/factory.rb

@@ -105,8 +105,7 @@ class StringFactory_ < Factory
       return nil
     end
     begin
-      externalces = Thread.current[:SOAPMapping][:ExternalCES]
-      encoded = XSD::Charset.encoding_conv(obj, externalces,
+      encoded = XSD::Charset.encoding_conv(obj, Mapping.external_ces,
         XSD::Charset.encoding)
       soap_obj = soap_class.new(encoded)
     rescue XSD::ValueSpaceError
@@ -119,13 +118,30 @@ class StringFactory_ < Factory
   def soap2obj(obj_class, node, info, map)
     obj = Mapping.create_empty_object(obj_class)
     decoded = XSD::Charset.encoding_conv(node.data, XSD::Charset.encoding,
-      Thread.current[:SOAPMapping][:ExternalCES])
+      Mapping.external_ces)
     obj.replace(decoded)
     mark_unmarshalled_obj(node, obj)
     return true, obj
   end
 end
 
+class FixnumFactory_ < Factory
+  def obj2soap(soap_class, obj, info, map)
+    soap_obj = nil
+    begin
+      soap_obj = soap_class.new(obj)
+    rescue XSD::ValueSpaceError
+      return nil
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = node.data
+    return true, obj
+  end
+end
+
 class BasetypeFactory_ < Factory
   def initialize(allow_original_mapping = false)
     super()

data/lib/soap/mapping/literalregistry.rb

@@ -48,9 +48,11 @@ class LiteralRegistry
 
   # node should be a SOAPElement
   def soap2obj(node, obj_class = nil)
+    cause = nil
     begin
       return any2obj(node, obj_class)
     rescue MappingError
+      cause = $!
     end
     if @excn_handler_soap2obj
       begin
@@ -60,7 +62,7 @@ class LiteralRegistry
       rescue Exception
       end
     end
-    raise MappingError.new("cannot map #{node.elename.name}/#{node.type.name} to Ruby object")
+    raise MappingError.new("cannot map #{node.elename.name}/#{node.type.name} to Ruby object", cause)
   end
 
 private
@@ -76,7 +78,10 @@ private
     if obj.is_a?(SOAP::Mapping::Object)
       return mappingobj2soap(obj, qname)
     end
-    class_definition = schema_definition_from_class(obj_class || obj.class)
+    class_definition = schema_definition_from_class(obj.class)
+    if class_definition.nil? and obj_class
+      class_definition = schema_definition_from_class(obj_class)
+    end
     elename_definition = schema_definition_from_elename(qname)
     if !class_definition and !elename_definition
       # no definition found
@@ -122,25 +127,25 @@ private
   end
 
   def stubobj2soap(obj, qname, definition)
-    if obj.is_a?(::String)
+    if obj.nil?
+      ele = SOAPNil.new
+      ele.elename = qname
+    elsif obj.is_a?(::String)
       ele = SOAPElement.new(qname, obj)
     else
       ele = SOAPElement.new(qname)
     end
     ele.qualified = definition.qualified
-    if definition.type
+    if definition.type and (definition.basetype or Mapping.root_type_hint)
+      Mapping.reset_root_type_hint
       ele.extraattr[XSD::AttrTypeName] = definition.type
     end
     if qname.nil? and definition.elename
       ele.elename = definition.elename
     end
+    return ele if obj.nil?
     stubobj2soap_elements(obj, ele, definition.elements)
-    if definition.attributes
-      definition.attributes.each do |qname, param|
-        at = Mapping.get_attribute(obj, XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name))
-        ele.extraattr[qname] = at
-      end
-    end
+    add_definedattributes2soap(obj, ele, definition)
     ele
   end
 
@@ -174,8 +179,12 @@ private
           added = false
         else
           if child.respond_to?(:each) and definition.as_array?
-            child.each do |item|
-              ele.add(definedobj2soap(item, definition))
+            if child.empty?
+              added = false
+            else
+              child.each do |item|
+                ele.add(definedobj2soap(item, definition))
+              end
             end
           else
             ele.add(definedobj2soap(child, definition))
@@ -197,7 +206,9 @@ private
         ele.add(obj2soap(value, key))
       end
     end
-    add_attributes2soap(obj, ele)
+    obj.__xmlattr.each do |key, value|
+      ele.extraattr[key] = value
+    end
     ele
   end
 
@@ -219,7 +230,7 @@ private
     if is_compound
       if definition
         return elesoap2stubobj(node, obj_class, definition)
-      else
+      elsif node.is_a?(::SOAP::SOAPNameAccessible)
         return elesoap2plainobj(node)
       end
     end
@@ -230,8 +241,10 @@ private
 
   def elesoap2stubobj(node, obj_class, definition)
     obj = nil
-    if obj_class < ::String
+    if obj_class == ::String
       obj = node.text
+    elsif obj_class < ::String
+      obj = obj_class.new(node.text)
     else
       obj = Mapping.create_empty_object(obj_class)
       add_elesoap2stubobj(node, obj, definition)
@@ -242,7 +255,7 @@ private
 
   def elesoap2plainobj(node)
     obj = nil
-    if node.members.empty?
+    if !node.have_member
       obj = base2obj(node, ::SOAP::SOAPString)
     else
       obj = anytype2obj(node)
@@ -256,9 +269,7 @@ private
     if node.is_a?(::SOAP::SOAPBasetype)
       return node.data
     end
-    klass = ::SOAP::Mapping::Object
-    obj = klass.new
-    obj
+    ::SOAP::Mapping::Object.new
   end
 
   def add_elesoap2stubobj(node, obj, definition)
@@ -280,7 +291,7 @@ private
       end
     end
     if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
-      obj.replace(vars.values[0])
+      Array.instance_method(:replace).bind(obj).call(vars.values[0])
     else
       Mapping.set_attributes(obj, vars)
     end
@@ -309,13 +320,12 @@ private
     if attributes = definition.attributes
       define_xmlattr(obj)
       attributes.each do |qname, class_name|
-        attr = node.extraattr[qname]
-        next if attr.nil? or attr.empty?
-        child = attr
+        child = node.extraattr[qname]
+        next if child.nil?
         if class_name
           klass = Mapping.class_from_name(class_name)
           if klass.include?(::SOAP::SOAPBasetype)
-            child = klass.new(attr).data
+            child = klass.to_data(child)
           end
         end
         obj.__xmlattr[qname] = child
@@ -343,18 +353,20 @@ private
   # much memory for each singleton Object.  just instance_eval instead of it.
   def define_xmlattr_accessor(obj, qname)
     # untaint depends GenSupport.safemethodname
-    name = XSD::CodeGen::GenSupport.safemethodname('xmlattr_' + qname.name).untaint
-    # untaint depends QName#dump
-    qnamedump = qname.dump.untaint
-    obj.instance_eval <<-EOS
-      def #{name}
-        @__xmlattr[#{qnamedump}]
-      end
+    name = Mapping.safemethodname('xmlattr_' + qname.name).untaint
+    unless obj.respond_to?(name)
+      # untaint depends QName#dump
+      qnamedump = qname.dump.untaint
+      obj.instance_eval <<-EOS
+        def #{name}
+          @__xmlattr[#{qnamedump}]
+        end
 
-      def #{name}=(value)
-        @__xmlattr[#{qnamedump}] = value
-      end
-    EOS
+        def #{name}=(value)
+          @__xmlattr[#{qnamedump}] = value
+        end
+      EOS
+    end
   end
 
   # Mapping.define_attr_accessor calls define_method with proc and it exhausts

data/lib/soap/mapping/mapping.rb

@@ -204,18 +204,20 @@ module Mapping
   def self.const_from_name(name, lenient = false)
     const = ::Object
     name.sub(/\A::/, '').split('::').each do |const_str|
-      begin
-        if const.const_defined?(const_str)
-          const = const.const_get(const_str)
-          next
-        end
-      rescue NameError
-        if lenient
-          const_str = XSD::CodeGen::GenSupport.safeconstname(const_str)
+      if /\A[A-Z]/ =~ const_str
+        begin
           if const.const_defined?(const_str)
             const = const.const_get(const_str)
             next
           end
+        rescue NameError
+        end
+      end
+      if lenient
+        const_str = Mapping.safeconstname(const_str)
+        if const.const_defined?(const_str)
+          const = const.const_get(const_str)
+          next
         end
       end
       return nil
@@ -224,7 +226,11 @@ module Mapping
   end
 
   def self.class_from_name(name, lenient = false)
-    const = const_from_name(name, lenient)
+    unless lenient
+      const = const_from_name_nonlenient(name)
+    else
+      const = const_from_name(name, true)
+    end
     if const.is_a?(::Class)
       const
     else
@@ -233,7 +239,11 @@ module Mapping
   end
 
   def self.module_from_name(name, lenient = false)
-    const = const_from_name(name, lenient)
+    unless lenient
+      const = const_from_name_nonlenient(name)
+    else
+      const = const_from_name(name, true)
+    end
     if const.is_a?(::Module)
       const
     else
@@ -241,6 +251,15 @@ module Mapping
     end
   end
 
+  def self.const_from_name_nonlenient(name)
+    if Thread.current[:SOAPMapping]
+      Thread.current[:SOAPMapping][:ConstFromName][name] ||=
+        const_from_name(name)
+    else
+      const_from_name(name)
+    end
+  end
+
   def self.class2qname(klass)
     name = schema_type_definition(klass)
     namespace = schema_ns_definition(klass)
@@ -270,6 +289,14 @@ module Mapping
     end
   end
 
+  def self.to_qname(obj, ns = nil)
+    if obj.is_a?(XSD::QName)
+      obj
+    else
+      XSD::QName.new(ns, obj)
+    end
+  end
+
   def self.define_singleton_method(obj, name, &block)
     sclass = (class << obj; self; end)
     sclass.class_eval {
@@ -309,7 +336,7 @@ module Mapping
         return obj.__send__(attr_name)
       end
       iv = obj.instance_variables
-      name = XSD::CodeGen::GenSupport.safevarname(attr_name)
+      name = Mapping.safevarname(attr_name)
       if iv.include?("@#{name}")
         return obj.instance_variable_get("@#{name}")
       elsif iv.include?("@#{attr_name}")
@@ -331,7 +358,7 @@ module Mapping
     else
       values.each do |attr_name, value|
         # untaint depends GenSupport.safevarname
-        name = XSD::CodeGen::GenSupport.safevarname(attr_name).untaint
+        name = Mapping.safevarname(attr_name).untaint
         setter = name + "="
         if obj.respond_to?(setter)
           obj.__send__(setter, value)
@@ -360,6 +387,33 @@ module Mapping
     end
   end
 
+  def self.safeconstname(name)
+    Thread.current[:SOAPMapping][:SafeConstName][name] ||=
+      XSD::CodeGen::GenSupport.safeconstname(name)
+  end
+
+  def self.safemethodname(name)
+    Thread.current[:SOAPMapping][:SafeMethodName][name] ||=
+      XSD::CodeGen::GenSupport.safemethodname(name)
+  end
+
+  def self.safevarname(name)
+    Thread.current[:SOAPMapping][:SafeVarName][name] ||=
+      XSD::CodeGen::GenSupport.safevarname(name)
+  end
+
+  def self.root_type_hint
+    Thread.current[:SOAPMapping][:RootTypeHint]
+  end
+
+  def self.reset_root_type_hint
+    Thread.current[:SOAPMapping][:RootTypeHint] = false
+  end
+
+  def self.external_ces
+    Thread.current[:SOAPMapping][:ExternalCES]
+  end
+
   def self.schema_ns_definition(klass)
     class_schema_variable(:schema_ns, klass)
   end
@@ -388,17 +442,19 @@ module Mapping
     if Thread.current[:SOAPMapping][:SchemaDefinition].key?(klass)
       return Thread.current[:SOAPMapping][:SchemaDefinition][klass]
     end
-    ns = schema_ns_definition(klass)
-    name = schema_name_definition(klass)
-    type = schema_type_definition(klass)
+    schema_ns = schema_ns_definition(klass)
+    schema_name = schema_name_definition(klass)
+    schema_type = schema_type_definition(klass)
     qualified = schema_qualified_definition(klass)
     elements = schema_element_definition(klass)
     attributes = schema_attribute_definition(klass)
-    return nil if ns.nil? and name.nil? and type.nil? and elements.nil? and attributes.nil?
+    return nil if schema_name.nil? and schema_type.nil?
+    schema_name = Mapping.to_qname(schema_name, schema_ns) if schema_name
+    schema_type = Mapping.to_qname(schema_type, schema_ns) if schema_type
     definition = create_schema_definition(klass,
-      :schema_ns => ns,
-      :schema_name => name,
-      :schema_type => type,
+      :schema_name => schema_name,
+      :schema_type => schema_type,
+      :is_anonymous => false,
       :schema_qualified => qualified,
       :schema_element => elements,
       :schema_attribute => attributes
@@ -411,20 +467,27 @@ module Mapping
     schema_ns = definition[:schema_ns]
     schema_name = definition[:schema_name]
     schema_type = definition[:schema_type]
+    is_anonymous = definition[:is_anonymous]
+    schema_basetype = definition[:schema_basetype]
+    # wrap if needed for backward compatibility
+    if schema_ns
+      schema_name = Mapping.to_qname(schema_name, schema_ns) if schema_name
+      schema_type = Mapping.to_qname(schema_type, schema_ns) if schema_type
+      # no need for schema_basetype bacause it's introduced later
+    end
     schema_qualified = definition[:schema_qualified]
     schema_element = definition[:schema_element]
     schema_attributes = definition[:schema_attribute]
-    elename = schema_name ? XSD::QName.new(schema_ns, schema_name) : nil
-    type = schema_type ? XSD::QName.new(schema_ns, schema_type) : nil
-    definition = SchemaDefinition.new(klass, elename, type, schema_qualified)
+    definition = SchemaDefinition.new(klass, schema_name, schema_type, is_anonymous, schema_qualified)
+    definition.basetype = schema_basetype
     definition.attributes = schema_attributes
     if schema_element
       if schema_element.respond_to?(:is_concrete_definition) and
           schema_element.is_concrete_definition
         definition.elements = schema_element
       else
-        default_ns = elename.namespace if elename
-        default_ns ||= type.namespace if type
+        default_ns = schema_name.namespace if schema_name
+        default_ns ||= schema_type.namespace if schema_type
         definition.elements = parse_schema_definition(schema_element, default_ns)
         if klass < ::Array
           definition.elements.set_array
@@ -520,7 +583,12 @@ module Mapping
         data[:MarshalKey] = {}
         data[:ExternalCES] = opt[:external_ces] || XSD::Charset.encoding
         data[:NoReference] = opt[:no_reference]
+        data[:RootTypeHint] = opt[:root_type_hint]
         data[:SchemaDefinition] = {}
+        data[:SafeConstName] = {}
+        data[:SafeMethodName] = {}
+        data[:SafeVarName] = {}
+        data[:ConstFromName] = {}
         yield
       end
     end