soap2r 1.5.8

data/lib/soap/mapping/schemadefinition.rb

@@ -0,0 +1,170 @@
+# SOAP4R - Ruby type mapping schema definition utility.
+# 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 'xsd/codegen/gensupport'
+
+
+module SOAP
+module Mapping
+
+
+class SchemaElementDefinition
+  attr_reader :varname, :mapped_class, :elename, :minoccurs, :maxoccurs
+
+  def initialize(varname, mapped_class, elename, minoccurs, maxoccurs,
+      as_any, as_array)
+    @varname = varname
+    @mapped_class = mapped_class
+    @elename = elename
+    @minoccurs = minoccurs
+    @maxoccurs = maxoccurs
+    @as_any = as_any
+    @as_array = as_array
+  end
+
+  def as_any?
+    @as_any
+  end
+
+  def as_array?
+    @as_array
+  end
+end
+
+module SchemaComplexTypeDefinition
+  include Enumerable
+
+  def initialize
+    @content = []
+    @element_cache = {}
+  end
+
+  def is_concrete_definition
+    true
+  end
+
+  def <<(ele)
+    @content << ele
+  end
+
+  def each
+    @content.each do |ele|
+      yield ele
+    end
+  end
+
+  def size
+    @content.size
+  end
+
+  def as_any?
+    false
+  end
+
+  def as_array?
+    false
+  end
+
+  def find_element(qname)
+    @element_cache[qname] ||= search_element(qname)
+  end
+
+private
+
+  def search_element(qname)
+    each do |ele|
+      if ele.respond_to?(:find_element)
+        found = ele.find_element(qname)
+        return found if found
+      else
+        # relaxed match
+        if ele.elename == qname or
+            (qname.namespace.nil? and ele.elename.name == qname.name)
+          return ele
+        end
+      end
+    end
+    nil
+  end
+end
+
+class SchemaEmptyDefinition
+  include SchemaComplexTypeDefinition
+
+  def initialize
+    super()
+    @content.freeze
+  end
+end
+
+class SchemaSequenceDefinition
+  include SchemaComplexTypeDefinition
+
+  def initialize
+    super()
+  end
+
+  def choice?
+    false
+  end
+
+  # override
+  def as_array?
+    @as_array ||= false
+  end
+
+  def set_array
+    @as_array = true
+  end
+end
+
+class SchemaChoiceDefinition
+  include SchemaComplexTypeDefinition
+
+  def initialize
+    super()
+  end
+
+  def choice?
+    true
+  end
+end
+
+class SchemaDefinition
+  EMPTY = SchemaEmptyDefinition.new
+
+  attr_reader :class_for
+  attr_reader :elename, :type
+  attr_reader :qualified
+  attr_accessor :basetype
+  attr_accessor :attributes
+  attr_accessor :elements
+
+  def initialize(class_for, elename, type, anonymous, qualified)
+    @class_for = class_for
+    @elename = elename
+    @type = type
+    @anonymous = anonymous
+    @qualified = qualified
+    @basetype = nil
+    @elements = EMPTY
+    @attributes = nil
+  end
+
+  def is_anonymous?
+    @anonymous
+  end
+
+  def choice?
+    @elements.choice?
+  end
+end
+
+
+end
+end

data/lib/soap/mapping/typeMap.rb

@@ -0,0 +1,106 @@
+# SOAP4R - Base type mapping definition
+# 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
+
+
+TypeMap = {
+  XSD::XSDAnySimpleType::Type => SOAPAnySimpleType,
+
+  XSD::XSDString::Type => SOAPString,
+  XSD::XSDNormalizedString::Type => SOAPNormalizedString,
+  XSD::XSDToken::Type => SOAPToken,
+  XSD::XSDLanguage::Type => SOAPLanguage,
+  XSD::XSDNMTOKEN::Type => SOAPNMTOKEN,
+  XSD::XSDNMTOKENS::Type => SOAPNMTOKENS,
+  XSD::XSDName::Type => SOAPName,
+  XSD::XSDNCName::Type => SOAPNCName,
+  XSD::XSDID::Type => SOAPID,
+  XSD::XSDIDREF::Type => SOAPIDREF,
+  XSD::XSDIDREFS::Type => SOAPIDREFS,
+  XSD::XSDENTITY::Type => SOAPENTITY,
+  XSD::XSDENTITIES::Type => SOAPENTITIES,
+  XSD::XSDBoolean::Type => SOAPBoolean,
+  XSD::XSDDecimal::Type => SOAPDecimal,
+  XSD::XSDFloat::Type => SOAPFloat,
+  XSD::XSDDouble::Type => SOAPDouble,
+  XSD::XSDDuration::Type => SOAPDuration,
+  XSD::XSDDateTime::Type => SOAPDateTime,
+  XSD::XSDTime::Type => SOAPTime,
+  XSD::XSDDate::Type => SOAPDate,
+  XSD::XSDGYearMonth::Type => SOAPGYearMonth,
+  XSD::XSDGYear::Type => SOAPGYear,
+  XSD::XSDGMonthDay::Type => SOAPGMonthDay,
+  XSD::XSDGDay::Type => SOAPGDay,
+  XSD::XSDGMonth::Type => SOAPGMonth,
+  XSD::XSDHexBinary::Type => SOAPHexBinary,
+  XSD::XSDBase64Binary::Type => SOAPBase64,
+  XSD::XSDAnyURI::Type => SOAPAnyURI,
+  XSD::XSDQName::Type => SOAPQName,
+  XSD::XSDInteger::Type => SOAPInteger,
+  XSD::XSDNonPositiveInteger::Type => SOAPNonPositiveInteger,
+  XSD::XSDNegativeInteger::Type => SOAPNegativeInteger,
+  XSD::XSDLong::Type => SOAPLong,
+  XSD::XSDInt::Type => SOAPInt,
+  XSD::XSDShort::Type => SOAPShort,
+  XSD::XSDByte::Type => SOAPByte,
+  XSD::XSDNonNegativeInteger::Type => SOAPNonNegativeInteger,
+  XSD::XSDUnsignedLong::Type => SOAPUnsignedLong,
+  XSD::XSDUnsignedInt::Type => SOAPUnsignedInt,
+  XSD::XSDUnsignedShort::Type => SOAPUnsignedShort,
+  XSD::XSDUnsignedByte::Type => SOAPUnsignedByte,
+  XSD::XSDPositiveInteger::Type => SOAPPositiveInteger,
+
+  # soap4r does not use soapenc types actively but it should be accepted.
+  SOAP::SOAPString::SOAPENCType => SOAPString,
+  SOAP::SOAPNormalizedString::Type => SOAPNormalizedString,
+  SOAP::SOAPToken::Type => SOAPToken,
+  SOAP::SOAPLanguage::Type => SOAPLanguage,
+  SOAP::SOAPNMTOKEN::Type => SOAPNMTOKEN,
+  SOAP::SOAPNMTOKENS::Type => SOAPNMTOKENS,
+  SOAP::SOAPName::Type => SOAPName,
+  SOAP::SOAPNCName::Type => SOAPNCName,
+  SOAP::SOAPID::Type => SOAPID,
+  SOAP::SOAPIDREF::Type => SOAPIDREF,
+  SOAP::SOAPIDREFS::Type => SOAPIDREFS,
+  SOAP::SOAPENTITY::Type => SOAPENTITY,
+  SOAP::SOAPENTITIES::Type => SOAPENTITIES,
+  SOAP::SOAPBoolean::SOAPENCType => SOAPBoolean,
+  SOAP::SOAPDecimal::SOAPENCType => SOAPDecimal,
+  SOAP::SOAPFloat::SOAPENCType => SOAPFloat,
+  SOAP::SOAPDouble::SOAPENCType => SOAPDouble,
+  SOAP::SOAPDuration::SOAPENCType => SOAPDuration,
+  SOAP::SOAPDateTime::SOAPENCType => SOAPDateTime,
+  SOAP::SOAPTime::SOAPENCType => SOAPTime,
+  SOAP::SOAPDate::SOAPENCType => SOAPDate,
+  SOAP::SOAPGYearMonth::SOAPENCType => SOAPGYearMonth,
+  SOAP::SOAPGYear::SOAPENCType => SOAPGYear,
+  SOAP::SOAPGMonthDay::SOAPENCType => SOAPGMonthDay,
+  SOAP::SOAPGDay::SOAPENCType => SOAPGDay,
+  SOAP::SOAPGMonth::SOAPENCType => SOAPGMonth,
+  SOAP::SOAPHexBinary::SOAPENCType => SOAPHexBinary,
+  SOAP::SOAPBase64::SOAPENCType => SOAPBase64,
+  SOAP::SOAPAnyURI::SOAPENCType => SOAPAnyURI,
+  SOAP::SOAPQName::SOAPENCType => SOAPQName,
+  SOAP::SOAPInteger::SOAPENCType => SOAPInteger,
+  SOAP::SOAPNonPositiveInteger::SOAPENCType => SOAPNonPositiveInteger,
+  SOAP::SOAPNegativeInteger::SOAPENCType => SOAPNegativeInteger,
+  SOAP::SOAPLong::SOAPENCType => SOAPLong,
+  SOAP::SOAPInt::SOAPENCType => SOAPInt,
+  SOAP::SOAPShort::SOAPENCType => SOAPShort,
+  SOAP::SOAPByte::SOAPENCType => SOAPByte,
+  SOAP::SOAPNonNegativeInteger::SOAPENCType => SOAPNonNegativeInteger,
+  SOAP::SOAPUnsignedLong::SOAPENCType => SOAPUnsignedLong,
+  SOAP::SOAPUnsignedInt::SOAPENCType => SOAPUnsignedInt,
+  SOAP::SOAPUnsignedShort::SOAPENCType => SOAPUnsignedShort,
+  SOAP::SOAPUnsignedByte::SOAPENCType => SOAPUnsignedByte,
+  SOAP::SOAPPositiveInteger::SOAPENCType => SOAPPositiveInteger,
+}
+
+
+end

data/lib/soap/mapping/wsdlencodedregistry.rb

@@ -0,0 +1,211 @@
+# SOAP4R - WSDL encoded 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 'xsd/qname'
+require 'xsd/namedelements'
+require 'soap/baseData'
+require 'soap/mapping/mapping'
+require 'soap/mapping/typeMap'
+
+
+module SOAP
+module Mapping
+
+
+class WSDLEncodedRegistry < EncodedRegistry
+  attr_reader :definedelements
+  attr_reader :definedtypes
+
+  def initialize(definedtypes = XSD::NamedElements::Empty)
+    super()
+    @definedtypes = definedtypes
+    # @definedelements = definedelements  needed?
+    # For mapping AnyType element.
+    @rubytype_factory = RubytypeFactory.new(
+      :allow_untyped_struct => true,
+      :allow_original_mapping => true
+    )
+  end
+
+  def obj2soap(obj, qname = nil)
+    soap_obj = nil
+    if type = @definedtypes[qname]
+      soap_obj = obj2typesoap(obj, type)
+    else
+      soap_obj = any2soap(obj, qname)
+    end
+    return soap_obj if soap_obj
+    if @excn_handler_obj2soap
+      soap_obj = @excn_handler_obj2soap.call(obj) { |yield_obj|
+        Mapping._obj2soap(yield_obj, self)
+      }
+      return soap_obj if soap_obj
+    end
+    if qname
+      raise MappingError.new("cannot map #{obj.class.name} as #{qname}")
+    else
+      raise MappingError.new("cannot map #{obj.class.name} to SOAP/OM")
+    end
+  end
+
+  # map anything for now: must refer WSDL while mapping.  [ToDo]
+  def soap2obj(node, obj_class = nil)
+    cause = nil
+    begin
+      unless obj_class
+        typestr = Mapping.safeconstname(node.elename.name)
+        obj_class = Mapping.class_from_name(typestr)
+      end
+      return Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class)
+    rescue MappingError
+      cause = $!
+    end
+    if @excn_handler_soap2obj
+      begin
+        return @excn_handler_soap2obj.call(node) { |yield_node|
+	    Mapping._soap2obj(yield_node, self)
+	  }
+      rescue Exception
+      end
+    end
+    raise MappingError.new("cannot map #{node.type.name} to Ruby object", cause)
+  end
+
+private
+
+  def any2soap(obj, qname)
+    ele = nil
+    if obj.nil?
+      ele = SOAPNil.new
+    elsif qname.nil? or qname == XSD::AnyTypeName
+      ele = @rubytype_factory.obj2soap(nil, obj, nil, self)
+    elsif obj.is_a?(XSD::NSDBase)
+      ele = soap2soap(obj, qname)
+    elsif type = TypeMap[qname]
+      ele = base2soap(obj, type)
+    end
+    add_attributes2soap(obj, ele) unless ele.nil?
+    ele
+  end
+
+  def soap2soap(obj, type_qname)
+    if obj.is_a?(SOAPBasetype)
+      obj
+    elsif obj.is_a?(SOAPStruct) && (type = @definedtypes[type_qname])
+      soap_obj = obj
+      mark_marshalled_obj(obj, soap_obj)
+      elements2soap(obj, soap_obj, type.elements)
+      soap_obj
+    elsif obj.is_a?(SOAPArray) && (type = @definedtypes[type_qname])
+      soap_obj = obj
+      contenttype = type.child_type
+      mark_marshalled_obj(obj, soap_obj)
+      obj.replace do |ele|
+	Mapping._obj2soap(ele, self, contenttype)
+      end
+      soap_obj
+    else
+      nil
+    end
+  end
+
+  def obj2typesoap(obj, type)
+    if type.is_a?(::WSDL::XMLSchema::SimpleType)
+      simpleobj2soap(obj, type)
+    else
+      complexobj2soap(obj, type)
+    end
+  end
+
+  def simpleobj2soap(obj, type)
+    type.check_lexical_format(obj)
+    return SOAPNil.new if obj.nil?      # TODO: check nillable.
+    if type.base
+      ele = base2soap(obj, TypeMap[type.base])
+      ele.type = type.name
+    elsif type.list
+      value = obj.is_a?(Array) ? obj.join(" ") : obj.to_s
+      ele = base2soap(value, SOAP::SOAPString)
+    else
+      raise MappingError.new("unsupported simpleType: #{type}")
+    end
+    ele
+  end
+
+  def complexobj2soap(obj, type)
+    case type.compoundtype
+    when :TYPE_STRUCT
+      struct2soap(obj, type.name, type)
+    when :TYPE_ARRAY
+      array2soap(obj, type.name, type)
+    when :TYPE_MAP
+      map2soap(obj, type.name, type)
+    when :TYPE_SIMPLE
+      simpleobj2soap(obj, type.simplecontent)
+    when :TYPE_EMPTY
+      raise MappingError.new("should be empty") unless obj.nil?
+      SOAPNil.new
+    else
+      raise MappingError.new("unknown compound type: #{type.compoundtype}")
+    end
+  end
+
+  def struct2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    soap_obj = SOAPStruct.new(type_qname)
+    mark_marshalled_obj(obj, soap_obj)
+    elements2soap(obj, soap_obj, type.elements)
+    soap_obj
+  end
+
+  def array2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    arytype = type.child_type
+    soap_obj = SOAPArray.new(ValueArrayName, 1, arytype)
+    unless obj.nil?
+      mark_marshalled_obj(obj, soap_obj)
+      obj.each do |item|
+        soap_obj.add(Mapping._obj2soap(item, self, arytype))
+      end
+    end
+    soap_obj
+  end
+
+  MapKeyName = XSD::QName.new(nil, "key")
+  MapValueName = XSD::QName.new(nil, "value")
+  def map2soap(obj, type_qname, type)
+    return SOAPNil.new if obj.nil?      # ToDo: check nillable.
+    keytype = type.child_type(MapKeyName) || XSD::AnyTypeName
+    valuetype = type.child_type(MapValueName) || XSD::AnyTypeName
+    soap_obj = SOAPStruct.new(MapQName)
+    unless obj.nil?
+      mark_marshalled_obj(obj, soap_obj)
+      obj.each do |key, value|
+        elem = SOAPStruct.new
+        elem.add("key", Mapping._obj2soap(key, self, keytype))
+        elem.add("value", Mapping._obj2soap(value, self, valuetype))
+        # ApacheAxis allows only 'item' here.
+        soap_obj.add("item", elem)
+      end
+    end
+    soap_obj
+  end
+
+  def elements2soap(obj, soap_obj, elements)
+    elements.each do |element|
+      name = element.name.name
+      child_obj = Mapping.get_attribute(obj, name)
+      soap_obj.add(name,
+        Mapping._obj2soap(child_obj, self, element.type || element.name))
+    end
+  end
+end
+
+
+end
+end