soap4r-spox 1.6.0

data/lib/soap/mapping/factory.rb

@@ -0,0 +1,388 @@
+# SOAP4R - Mapping factory.
+# 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;
+# either the dual license version in 2003, or any later version.
+
+
+module SOAP
+module Mapping
+
+
+class Factory
+  include TraverseSupport
+
+  def initialize
+    # nothing to do
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    raise NotImplementError.new
+    # return soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    raise NotImplementError.new
+    # return convert_succeeded_or_not, obj
+  end
+
+  def setiv2obj(obj, node, map)
+    return if node.nil?
+    if obj.is_a?(Array)
+      setiv2ary(obj, node, map)
+    else
+      setiv2struct(obj, node, map)
+    end
+  end
+
+  def setiv2soap(node, obj, map)
+    if obj.class.class_variables.include?(:@@schema_element)
+      setdefinediv2soap(node, obj, map)
+    else
+      # should we sort instance_variables? how?
+      obj.instance_variables.each do |var|
+        name = var.to_s.sub(/^@/, '').to_sym
+        elename = Mapping.name2elename(name)
+        node.add(elename,
+          Mapping._obj2soap(obj.instance_variable_get(var), map))
+      end
+    end
+  end
+
+private
+
+  def setdefinediv2soap(ele, obj, map)
+    definition = Mapping.schema_definition_classdef(obj.class)
+    definition.elements.each do |eledef|
+      child = Mapping.get_attribute(obj, eledef.varname)
+      # extract method
+      if child.nil?
+        value = SOAPNil.new
+      elsif child.is_a?(XSD::NSDBase)
+        value = child
+      else
+        klass = Mapping.class_from_name(eledef.type)
+        if klass && klass.include?(::SOAP::SOAPBasetype)
+          value = klass.new(child)
+        else
+          # should check klass matches an actual object?
+          value = Mapping._obj2soap(child, map)
+        end
+      end
+      ele.add(eledef.elename.name, value)
+    end
+  end
+
+  def setiv2ary(obj, node, map)
+    node.each do |name, value|
+      Array.instance_method(:<<).bind(obj).call(Mapping._soap2obj(value, map))
+    end
+  end
+
+  def setiv2struct(obj, node, map)
+    vars = {}
+    node.each do |name, value|
+      vars[Mapping.elename2name(name)] = Mapping._soap2obj(value, map)
+    end
+    Mapping.set_attributes(obj, vars)
+  end
+
+  def anonymous_class?(obj)
+    name = obj.class.name
+    name.nil? or name.empty?    # 1.8 returns ""
+  end
+end
+
+class StringFactory_ < Factory
+  def initialize(allow_original_mapping = false)
+    super()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and !obj.instance_variables.empty?
+      return nil
+    end
+    begin
+      encoded = XSD::Charset.encoding_conv(obj, Mapping.external_ces,
+        XSD::Charset.encoding)
+      soap_obj = soap_class.new(encoded)
+    rescue XSD::ValueSpaceError
+      return nil
+    end
+    mark_marshalled_obj(obj, soap_obj)
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = Mapping.create_empty_object(obj_class)
+    decoded = XSD::Charset.encoding_conv(node.data, XSD::Charset.encoding,
+      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()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and !obj.instance_variables.empty?
+      return nil
+    end
+    soap_obj = nil
+    begin
+      soap_obj = soap_class.new(obj)
+    rescue XSD::ValueSpaceError
+      return nil
+    end
+    if @allow_original_mapping
+      # Basetype except String should not be multiref-ed in SOAP/1.1.
+      mark_marshalled_obj(obj, soap_obj)
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = node.data
+    mark_unmarshalled_obj(node, obj)
+    return true, obj
+  end
+end
+
+class DateTimeFactory_ < Factory
+  def initialize(allow_original_mapping = false)
+    super()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and
+	Time === obj and !obj.instance_variables.empty?
+      return nil
+    end
+    soap_obj = nil
+    begin
+      soap_obj = soap_class.new(obj)
+    rescue XSD::ValueSpaceError
+      return nil
+    end
+    mark_marshalled_obj(obj, soap_obj)
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    if node.respond_to?(:to_obj)
+      obj = node.to_obj(obj_class)
+      return false if obj.nil?
+      mark_unmarshalled_obj(node, obj)
+      return true, obj
+    else
+      return false
+    end
+  end
+end
+
+class Base64Factory_ < Factory
+  def obj2soap(soap_class, obj, info, map)
+    return nil unless obj.instance_variables.empty?
+    soap_obj = soap_class.new(obj)
+    mark_marshalled_obj(obj, soap_obj) if soap_obj
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = node.string
+    mark_unmarshalled_obj(node, obj)
+    return true, obj
+  end
+end
+
+class URIFactory_ < Factory
+  def obj2soap(soap_class, obj, info, map)
+    soap_obj = soap_class.new(obj)
+    mark_marshalled_obj(obj, soap_obj) if soap_obj
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = node.data
+    mark_unmarshalled_obj(node, obj)
+    return true, obj
+  end
+end
+
+class ArrayFactory_ < Factory
+  def initialize(allow_original_mapping = false)
+    super()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  # [[1], [2]] is converted to Array of Array, not 2-D Array.
+  # To create M-D Array, you must call Mapping.ary2md.
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and !obj.instance_variables.empty?
+      return nil
+    end
+    arytype = Mapping.obj2element(obj)
+    if arytype.name
+      arytype.namespace ||= RubyTypeNamespace
+    else
+      arytype = XSD::AnyTypeName
+    end
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    mark_marshalled_obj(obj, soap_obj)
+    obj.each do |item|
+      soap_obj.add(Mapping._obj2soap(item, map))
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    obj = Mapping.create_empty_object(obj_class)
+    mark_unmarshalled_obj(node, obj)
+    node.soap2array(obj) do |elem|
+      elem ? Mapping._soap2obj(elem, map) : nil
+    end
+    return true, obj
+  end
+end
+
+class TypedArrayFactory_ < Factory
+  def initialize(allow_original_mapping = false)
+    super()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and !obj.instance_variables.empty?
+      return nil
+    end
+    arytype = info[:type] || info[0]
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    mark_marshalled_obj(obj, soap_obj)
+    obj.each do |var|
+      soap_obj.add(Mapping._obj2soap(var, map))
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    if node.rank > 1
+      return false
+    end
+    arytype = info[:type] || info[0]
+    unless node.arytype == arytype
+      return false
+    end
+    obj = Mapping.create_empty_object(obj_class)
+    mark_unmarshalled_obj(node, obj)
+    node.soap2array(obj) do |elem|
+      elem ? Mapping._soap2obj(elem, map) : nil
+    end
+    return true, obj
+  end
+end
+
+class TypedStructFactory_ < Factory
+  def obj2soap(soap_class, obj, info, map)
+    type = info[:type] || info[0]
+    soap_obj = soap_class.new(type)
+    mark_marshalled_obj(obj, soap_obj)
+    if obj.class <= SOAP::Marshallable
+      setiv2soap(soap_obj, obj, map)
+    else
+      # allow to serialize an instance of unmarked class
+      setiv2soap(soap_obj, obj, map)
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    type = info[:type] || info[0]
+    unless node.type == type
+      return false
+    end
+    obj = Mapping.create_empty_object(obj_class)
+    mark_unmarshalled_obj(node, obj)
+    setiv2obj(obj, node, map)
+    return true, obj
+  end
+end
+
+MapQName = XSD::QName.new(ApacheSOAPTypeNamespace, 'Map')
+class HashFactory_ < Factory
+  def initialize(allow_original_mapping = false)
+    super()
+    @allow_original_mapping = allow_original_mapping
+  end
+
+  def obj2soap(soap_class, obj, info, map)
+    if !@allow_original_mapping and !obj.instance_variables.empty?
+      return nil
+    end
+    if !obj.default.nil? or
+	(obj.respond_to?(:default_proc) and obj.default_proc)
+      return nil
+    end
+    soap_obj = SOAPStruct.new(MapQName)
+    mark_marshalled_obj(obj, soap_obj)
+    obj.each do |key, value|
+      elem = SOAPStruct.new
+      elem.add("key", Mapping._obj2soap(key, map))
+      elem.add("value", Mapping._obj2soap(value, map))
+      # ApacheAxis allows only 'item' here.
+      soap_obj.add("item", elem)
+    end
+    soap_obj
+  end
+
+  def soap2obj(obj_class, node, info, map)
+    unless node.type == MapQName
+      return false
+    end
+    if node.class == SOAPStruct and node.key?('default')
+      return false
+    end
+    obj = Mapping.create_empty_object(obj_class)
+    mark_unmarshalled_obj(node, obj)
+    if node.class == SOAPStruct
+      node.each do |key, value|
+	obj[Mapping._soap2obj(value['key'], map)] =
+	  Mapping._soap2obj(value['value'], map)
+      end
+    else
+      node.each do |value|
+	obj[Mapping._soap2obj(value['key'], map)] =
+	  Mapping._soap2obj(value['value'], map)
+      end
+    end
+    return true, obj
+  end
+end
+
+
+end
+end

data/lib/soap/mapping/literalregistry.rb

@@ -0,0 +1,391 @@
+# SOAP4R - literal mapping registry.
+# 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;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/baseData'
+require 'soap/mapping/mapping'
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+require 'xsd/namedelements'
+
+
+module SOAP
+module Mapping
+
+
+class LiteralRegistry
+  include RegistrySupport
+
+  attr_accessor :excn_handler_obj2soap
+  attr_accessor :excn_handler_soap2obj
+
+  def initialize
+    super()
+    @excn_handler_obj2soap = nil
+    @excn_handler_soap2obj = nil
+  end
+
+  def obj2soap(obj, qname, obj_class = nil)
+    soap_obj = nil
+    if obj.is_a?(SOAPElement)
+      soap_obj = obj
+    else
+      soap_obj = any2soap(obj, qname, obj_class)
+    end
+    return soap_obj if soap_obj
+    if @excn_handler_obj2soap
+      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
+        Mapping.obj2soap(yield_obj, nil, nil, MAPPING_OPT)
+      }
+      return soap_obj if soap_obj
+    end
+    raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
+  end
+
+  # 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
+        return @excn_handler_soap2obj.call(node) { |yield_node|
+	    Mapping.soap2obj(yield_node, nil, nil, MAPPING_OPT)
+	  }
+      rescue Exception
+      end
+    end
+    raise MappingError.new("cannot map #{node.elename.name}/#{node.type.name} to Ruby object", cause)
+  end
+
+private
+
+  MAPPING_OPT = { :no_reference => true }
+
+  def definedobj2soap(obj, definition)
+    obj2soap(obj, definition.elename, definition.mapped_class)
+  end
+
+  def any2soap(obj, qname, obj_class)
+    ele = nil
+    if obj.is_a?(SOAP::Mapping::Object)
+      return mappingobj2soap(obj, qname)
+    end
+    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
+      return anyobj2soap(obj, qname)
+    end
+    if !class_definition or !elename_definition
+      # use found one
+      return stubobj2soap(obj, qname, class_definition || elename_definition)
+    end
+    # found both:
+    if class_definition.class_for == elename_definition.class_for
+      # if two definitions are for the same class, give qname a priority.
+      return stubobj2soap(obj, qname, elename_definition)
+    end
+    # it should be a derived class
+    return stubobj2soap(obj, qname, class_definition)
+  end
+
+  def anyobj2soap(obj, qname)
+    ele = nil
+    case obj
+    when Hash
+      ele = SOAPElement.from_obj(obj, nil)
+      ele.elename = qname
+    when Array
+      # treat as a list of simpletype
+      ele = SOAPElement.new(qname, obj.join(" "))
+    when XSD::QName
+      ele = SOAPElement.new(qname)
+      ele.text = obj
+    else
+      # expected to be a basetype or an anyType.
+      # SOAPStruct, etc. is used instead of SOAPElement.
+      begin
+        ele = Mapping.obj2soap(obj, nil, nil, MAPPING_OPT)
+        ele.elename = qname
+      rescue MappingError
+        ele = SOAPElement.new(qname, obj.to_s)
+      end
+    end
+    add_attributes2soap(obj, ele)
+    ele
+  end
+
+  def stubobj2soap(obj, qname, definition)
+    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
+      ele.type = definition.type
+      if definition.basetype or Mapping.root_type_hint
+        Mapping.reset_root_type_hint
+        ele.force_typed = true
+      end
+    end
+    if qname.nil? and definition.elename
+      ele.elename = definition.elename
+    end
+    return ele if obj.nil?
+    stubobj2soap_elements(obj, ele, definition.elements)
+    add_definedattributes2soap(obj, ele, definition)
+    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(definedobj2soap(item, definition))
+        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?
+            if child.empty?
+              added = false
+            else
+              child.each do |item|
+                ele.add(definedobj2soap(item, definition))
+              end
+            end
+          else
+            ele.add(definedobj2soap(child, definition))
+          end
+        end
+      end
+    end
+    added
+  end
+
+  def mappingobj2soap(obj, qname)
+    ele = SOAPElement.new(qname)
+    obj.__xmlele.each do |key, value|
+      if value.is_a?(::Array)
+        value.each do |item|
+          ele.add(obj2soap(item, key))
+        end
+      else
+        ele.add(obj2soap(value, key))
+      end
+    end
+    obj.__xmlattr.each do |key, value|
+      ele.extraattr[key] = value
+    end
+    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)
+    end
+    if definition
+      obj_class = definition.class_for
+    end
+    if is_compound
+      if definition
+        return elesoap2stubobj(node, obj_class, definition)
+      elsif node.is_a?(::SOAP::SOAPNameAccessible)
+        return elesoap2plainobj(node)
+      end
+    end
+    obj = Mapping.soap2obj(node, nil, obj_class, MAPPING_OPT)
+    add_attributes2obj(node, obj)
+    obj
+  end
+
+  def elesoap2stubobj(node, obj_class, definition)
+    obj = nil
+    if obj_class == ::String
+      obj = node.text
+    elsif obj_class < ::String and node.respond_to?(:text)
+      obj = obj_class.new(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 = nil
+    if !node.have_member
+      obj = base2obj(node, ::SOAP::SOAPString)
+    else
+      obj = anytype2obj(node)
+      add_elesoap2plainobj(node, obj)
+    end
+    add_attributes2obj(node, obj)
+    obj
+  end
+
+  def anytype2obj(node)
+    if node.is_a?(::SOAP::SOAPBasetype)
+      return node.data
+    end
+    ::SOAP::Mapping::Object.new
+  end
+
+  def add_elesoap2stubobj(node, obj, definition)
+    vars = {}
+    node.each do |name, value|
+      item = definition.elements.find_element(value.elename)
+      if item
+        child = elesoapchild2obj(value, item)
+      else
+        # unknown element is treated as anyType.
+        child = any2obj(value)
+      end
+      if item and item.as_array?
+        (vars[name] ||= []) << child
+      elsif vars.key?(name)
+        vars[name] = [vars[name], child].flatten
+      else
+        vars[name] = child
+      end
+    end
+    if obj.is_a?(::Array) and is_stubobj_elements_for_array(vars)
+      Array.instance_method(:replace).bind(obj).call(vars.values[0])
+    else
+      Mapping.set_attributes(obj, vars)
+    end
+  end
+
+  def elesoapchild2obj(value, eledef)
+    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
+        # untyped element is treated as anyType.
+        any2obj(value)
+      end
+    end
+  end
+
+  def add_attributes2stubobj(node, obj, definition)
+    return if obj.nil? or node.extraattr.empty?
+    if attributes = definition.attributes
+      define_xmlattr(obj)
+      attributes.each do |qname, class_name|
+        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.to_data(child)
+          end
+        end
+        obj.__xmlattr[qname] = child
+        define_xmlattr_accessor(obj, qname)
+      end
+    end
+  end
+
+  def add_elesoap2plainobj(node, obj)
+    node.each do |name, value|
+      obj.__add_xmlele_value(value.elename, any2obj(value))
+    end
+  end
+
+  def add_attributes2obj(node, obj)
+    return if obj.nil? or node.extraattr.empty?
+    define_xmlattr(obj)
+    node.extraattr.each do |qname, value|
+      obj.__xmlattr[qname] = value
+      define_xmlattr_accessor(obj, qname)
+    end
+  end
+
+  # Mapping.define_attr_accessor calls define_method with proc and it exhausts
+  # much memory for each singleton Object.  just instance_eval instead of it.
+  def define_xmlattr_accessor(obj, qname)
+    # untaint depends GenSupport.safemethodname
+    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
+    end
+  end
+
+  # Mapping.define_attr_accessor calls define_method with proc and it exhausts
+  # much memory for each singleton Object.  just instance_eval instead of it.
+  def define_xmlattr(obj)
+    obj.instance_variable_set('@__xmlattr', {})
+    unless obj.respond_to?(:__xmlattr)
+      obj.instance_eval <<-EOS
+        def __xmlattr
+          @__xmlattr
+        end
+      EOS
+    end
+  end
+end
+
+
+end
+end