diff options
Diffstat (limited to 'ruby_1_8_6/lib/soap/mapping')
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/factory.rb | 355 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/mapping.rb | 381 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/registry.rb | 541 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/rubytypeFactory.rb | 475 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/typeMap.rb | 50 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/wsdlencodedregistry.rb | 280 | ||||
| -rw-r--r-- | ruby_1_8_6/lib/soap/mapping/wsdlliteralregistry.rb | 418 |
7 files changed, 0 insertions, 2500 deletions
diff --git a/ruby_1_8_6/lib/soap/mapping/factory.rb b/ruby_1_8_6/lib/soap/mapping/factory.rb deleted file mode 100644 index 978b303b3d..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/factory.rb +++ /dev/null @@ -1,355 +0,0 @@ -# SOAP4R - Mapping factory. -# Copyright (C) 2000, 2001, 2002, 2003 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') - obj.class.class_eval('@@schema_element').each do |name, info| - type, qname = info - if qname - elename = qname.name - else - elename = Mapping.name2elename(name) - end - node.add(elename, - Mapping._obj2soap(obj.instance_variable_get('@' + name), map)) - end - else - # should we sort instance_variables? - obj.instance_variables.each do |var| - name = var.sub(/^@/, '') - elename = Mapping.name2elename(name) - node.add(elename, - Mapping._obj2soap(obj.instance_variable_get(var), map)) - end - end - end - -private - - 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 -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 - unless XSD::Charset.is_ces(obj, Thread.current[:SOAPExternalCES]) - return nil - end - encoded = XSD::Charset.encoding_conv(obj, - Thread.current[:SOAPExternalCES], 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, - Thread.current[:SOAPExternalCES]) - obj.replace(decoded) - mark_unmarshalled_obj(node, obj) - 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 - 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 diff --git a/ruby_1_8_6/lib/soap/mapping/mapping.rb b/ruby_1_8_6/lib/soap/mapping/mapping.rb deleted file mode 100644 index 65d6bb4d5b..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/mapping.rb +++ /dev/null @@ -1,381 +0,0 @@ -# SOAP4R - Ruby type mapping utility. -# Copyright (C) 2000, 2001, 2003-2005 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 - RubyTypeNamespace = 'http://www.ruby-lang.org/xmlns/ruby/type/1.6' - RubyTypeInstanceNamespace = - 'http://www.ruby-lang.org/xmlns/ruby/type-instance' - RubyCustomTypeNamespace = 'http://www.ruby-lang.org/xmlns/ruby/type/custom' - ApacheSOAPTypeNamespace = 'http://xml.apache.org/xml-soap' - - - # TraverseSupport breaks following thread variables. - # Thread.current[:SOAPMarshalDataKey] - module TraverseSupport - def mark_marshalled_obj(obj, soap_obj) - raise if obj.nil? - Thread.current[:SOAPMarshalDataKey][obj.__id__] = soap_obj - end - - def mark_unmarshalled_obj(node, obj) - return if obj.nil? - # node.id is not Object#id but SOAPReference#id - Thread.current[:SOAPMarshalDataKey][node.id] = obj - end - end - - - EMPTY_OPT = {} - def self.obj2soap(obj, registry = nil, type = nil, opt = EMPTY_OPT) - registry ||= Mapping::DefaultRegistry - soap_obj = nil - protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do - Thread.current[:SOAPMarshalDataKey] = {} - Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE - Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] - soap_obj = _obj2soap(obj, registry, type) - end - soap_obj - end - - def self.soap2obj(node, registry = nil, klass = nil, opt = EMPTY_OPT) - registry ||= Mapping::DefaultRegistry - obj = nil - protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do - Thread.current[:SOAPMarshalDataKey] = {} - Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE - Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] - obj = _soap2obj(node, registry, klass) - end - obj - end - - def self.ary2soap(ary, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) - registry ||= Mapping::DefaultRegistry - type = XSD::QName.new(type_ns, typename) - soap_ary = SOAPArray.new(ValueArrayName, 1, type) - protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do - Thread.current[:SOAPMarshalDataKey] = {} - Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE - Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] - ary.each do |ele| - soap_ary.add(_obj2soap(ele, registry, type)) - end - end - soap_ary - end - - def self.ary2md(ary, rank, type_ns = XSD::Namespace, typename = XSD::AnyTypeLiteral, registry = nil, opt = EMPTY_OPT) - registry ||= Mapping::DefaultRegistry - type = XSD::QName.new(type_ns, typename) - md_ary = SOAPArray.new(ValueArrayName, rank, type) - protect_threadvars(:SOAPMarshalDataKey, :SOAPExternalCES, :SOAPMarshalNoReference) do - Thread.current[:SOAPMarshalDataKey] = {} - Thread.current[:SOAPExternalCES] = opt[:external_ces] || $KCODE - Thread.current[:SOAPMarshalNoReference] = opt[:no_reference] - add_md_ary(md_ary, ary, [], registry) - end - md_ary - end - - def self.fault2exception(fault, registry = nil) - registry ||= Mapping::DefaultRegistry - detail = if fault.detail - soap2obj(fault.detail, registry) || "" - else - "" - end - if detail.is_a?(Mapping::SOAPException) - begin - e = detail.to_e - remote_backtrace = e.backtrace - e.set_backtrace(nil) - raise e # ruby sets current caller as local backtrace of e => e2. - rescue Exception => e - e.set_backtrace(remote_backtrace + e.backtrace[1..-1]) - raise - end - else - fault.detail = detail - fault.set_backtrace( - if detail.is_a?(Array) - detail - else - [detail.to_s] - end - ) - raise - end - end - - def self._obj2soap(obj, registry, type = nil) - if referent = Thread.current[:SOAPMarshalDataKey][obj.__id__] and - !Thread.current[:SOAPMarshalNoReference] - SOAPReference.new(referent) - elsif registry - registry.obj2soap(obj, type) - else - raise MappingError.new("no mapping registry given") - end - end - - def self._soap2obj(node, registry, klass = nil) - if node.nil? - return nil - elsif node.is_a?(SOAPReference) - target = node.__getobj__ - # target.id is not Object#id but SOAPReference#id - if referent = Thread.current[:SOAPMarshalDataKey][target.id] and - !Thread.current[:SOAPMarshalNoReference] - return referent - else - return _soap2obj(target, registry, klass) - end - end - return registry.soap2obj(node, klass) - end - - if Object.respond_to?(:allocate) - # ruby/1.7 or later. - def self.create_empty_object(klass) - klass.allocate - end - else - MARSHAL_TAG = { - String => ['"', 1], - Regexp => ['/', 2], - Array => ['[', 1], - Hash => ['{', 1] - } - def self.create_empty_object(klass) - if klass <= Struct - name = klass.name - return ::Marshal.load(sprintf("\004\006S:%c%s\000", name.length + 5, name)) - end - if MARSHAL_TAG.has_key?(klass) - tag, terminate = MARSHAL_TAG[klass] - return ::Marshal.load(sprintf("\004\006%s%s", tag, "\000" * terminate)) - end - MARSHAL_TAG.each do |k, v| - if klass < k - name = klass.name - tag, terminate = v - return ::Marshal.load(sprintf("\004\006C:%c%s%s%s", name.length + 5, name, tag, "\000" * terminate)) - end - end - name = klass.name - ::Marshal.load(sprintf("\004\006o:%c%s\000", name.length + 5, name)) - end - end - - # Allow only (Letter | '_') (Letter | Digit | '-' | '_')* here. - # Caution: '.' is not allowed here. - # To follow XML spec., it should be NCName. - # (denied chars) => .[0-F][0-F] - # ex. a.b => a.2eb - # - def self.name2elename(name) - name.gsub(/([^a-zA-Z0-9:_\-]+)/n) { - '.' << $1.unpack('H2' * $1.size).join('.') - }.gsub(/::/n, '..') - end - - def self.elename2name(name) - name.gsub(/\.\./n, '::').gsub(/((?:\.[0-9a-fA-F]{2})+)/n) { - [$1.delete('.')].pack('H*') - } - end - - 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) - 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 - end - end - return nil - end - const - end - - def self.class_from_name(name, lenient = false) - const = const_from_name(name, lenient) - if const.is_a?(::Class) - const - else - nil - end - end - - def self.module_from_name(name, lenient = false) - const = const_from_name(name, lenient) - if const.is_a?(::Module) - const - else - nil - end - end - - def self.class2qname(klass) - name = schema_type_definition(klass) - namespace = schema_ns_definition(klass) - XSD::QName.new(namespace, name) - end - - def self.class2element(klass) - type = Mapping.class2qname(klass) - type.name ||= Mapping.name2elename(klass.name) - type.namespace ||= RubyCustomTypeNamespace - type - end - - def self.obj2element(obj) - name = namespace = nil - ivars = obj.instance_variables - if ivars.include?('@schema_type') - name = obj.instance_variable_get('@schema_type') - end - if ivars.include?('@schema_ns') - namespace = obj.instance_variable_get('@schema_ns') - end - if !name or !namespace - class2qname(obj.class) - else - XSD::QName.new(namespace, name) - end - end - - def self.define_singleton_method(obj, name, &block) - sclass = (class << obj; self; end) - sclass.class_eval { - define_method(name, &block) - } - end - - def self.get_attribute(obj, attr_name) - if obj.is_a?(::Hash) - obj[attr_name] || obj[attr_name.intern] - else - name = XSD::CodeGen::GenSupport.safevarname(attr_name) - if obj.instance_variables.include?('@' + name) - obj.instance_variable_get('@' + name) - elsif ((obj.is_a?(::Struct) or obj.is_a?(Marshallable)) and - obj.respond_to?(name)) - obj.__send__(name) - end - end - end - - def self.set_attributes(obj, values) - if obj.is_a?(::SOAP::Mapping::Object) - values.each do |attr_name, value| - obj.__add_xmlele_value(attr_name, value) - end - else - values.each do |attr_name, value| - name = XSD::CodeGen::GenSupport.safevarname(attr_name) - setter = name + "=" - if obj.respond_to?(setter) - obj.__send__(setter, value) - else - obj.instance_variable_set('@' + name, value) - begin - define_attr_accessor(obj, name, - proc { instance_variable_get('@' + name) }, - proc { |value| instance_variable_set('@' + name, value) }) - rescue TypeError - # singleton class may not exist (e.g. Float) - end - end - end - end - end - - def self.define_attr_accessor(obj, name, getterproc, setterproc = nil) - define_singleton_method(obj, name, &getterproc) - define_singleton_method(obj, name + '=', &setterproc) if setterproc - end - - def self.schema_type_definition(klass) - class_schema_variable(:schema_type, klass) - end - - def self.schema_ns_definition(klass) - class_schema_variable(:schema_ns, klass) - end - - def self.schema_element_definition(klass) - schema_element = class_schema_variable(:schema_element, klass) or return nil - schema_ns = schema_ns_definition(klass) - elements = [] - as_array = [] - schema_element.each do |varname, definition| - class_name, name = definition - if /\[\]$/ =~ class_name - class_name = class_name.sub(/\[\]$/, '') - as_array << (name ? name.name : varname) - end - elements << [name || XSD::QName.new(schema_ns, varname), class_name] - end - [elements, as_array] - end - - def self.schema_attribute_definition(klass) - class_schema_variable(:schema_attribute, klass) - end - - class << Mapping - private - - def class_schema_variable(sym, klass) - var = "@@#{sym}" - klass.class_variables.include?(var) ? klass.class_eval(var) : nil - 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) - add_md_ary(md_ary, ary[idx], indices + [idx], registry) - else - md_ary[*(indices + [idx])] = _obj2soap(ary[idx], registry) - end - end - end - end -end - - -end diff --git a/ruby_1_8_6/lib/soap/mapping/registry.rb b/ruby_1_8_6/lib/soap/mapping/registry.rb deleted file mode 100644 index 823e80666d..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/registry.rb +++ /dev/null @@ -1,541 +0,0 @@ -# SOAP4R - Mapping registry. -# Copyright (C) 2000, 2001, 2002, 2003 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 'soap/mapping/factory' -require 'soap/mapping/rubytypeFactory' - - -module SOAP - - -module Marshallable - # @@type_ns = Mapping::RubyCustomTypeNamespace -end - - -module Mapping - - -module MappedException; end - - -RubyTypeName = XSD::QName.new(RubyTypeInstanceNamespace, 'rubyType') -RubyExtendName = XSD::QName.new(RubyTypeInstanceNamespace, 'extends') -RubyIVarName = XSD::QName.new(RubyTypeInstanceNamespace, 'ivars') - - -# Inner class to pass an exception. -class SOAPException; include Marshallable - attr_reader :excn_type_name, :cause - def initialize(e) - @excn_type_name = Mapping.name2elename(e.class.to_s) - @cause = e - end - - def to_e - if @cause.is_a?(::Exception) - @cause.extend(::SOAP::Mapping::MappedException) - return @cause - elsif @cause.respond_to?(:message) and @cause.respond_to?(:backtrace) - e = RuntimeError.new(@cause.message) - e.set_backtrace(@cause.backtrace) - return e - end - klass = Mapping.class_from_name(Mapping.elename2name(@excn_type_name.to_s)) - if klass.nil? or not klass <= ::Exception - return RuntimeError.new(@cause.inspect) - end - obj = klass.new(@cause.message) - obj.extend(::SOAP::Mapping::MappedException) - obj - end -end - - -# For anyType object: SOAP::Mapping::Object not ::Object -class Object; include Marshallable - def initialize - @__xmlele_type = {} - @__xmlele = [] - @__xmlattr = {} - end - - def inspect - sprintf("#<%s:0x%x%s>", self.class.name, __id__, - @__xmlele.collect { |name, value| " #{name}=#{value.inspect}" }.join) - end - - def __xmlattr - @__xmlattr - end - - def __xmlele - @__xmlele - end - - def [](qname) - unless qname.is_a?(XSD::QName) - qname = XSD::QName.new(nil, qname) - end - @__xmlele.each do |k, v| - return v if k == qname - end - # fallback - @__xmlele.each do |k, v| - return v if k.name == qname.name - end - nil - end - - def []=(qname, value) - unless qname.is_a?(XSD::QName) - qname = XSD::QName.new(nil, qname) - end - found = false - @__xmlele.each do |pair| - if pair[0] == qname - found = true - pair[1] = value - end - end - unless found - __define_attr_accessor(qname) - @__xmlele << [qname, value] - end - @__xmlele_type[qname] = :single - end - - def __add_xmlele_value(qname, value) - found = false - @__xmlele.map! do |k, v| - if k == qname - found = true - [k, __set_xmlele_value(k, v, value)] - else - [k, v] - end - end - unless found - __define_attr_accessor(qname) - @__xmlele << [qname, value] - @__xmlele_type[qname] = :single - end - value - end - -private - - if RUBY_VERSION > "1.7.0" - def __define_attr_accessor(qname) - name = XSD::CodeGen::GenSupport.safemethodname(qname.name) - Mapping.define_attr_accessor(self, name, - proc { self[qname] }, - proc { |value| self[qname] = value }) - end - else - def __define_attr_accessor(qname) - name = XSD::CodeGen::GenSupport.safemethodname(qname.name) - instance_eval <<-EOS - def #{name} - self[#{qname.dump}] - end - - def #{name}=(value) - self[#{qname.dump}] = value - end - EOS - end - end - - def __set_xmlele_value(key, org, value) - case @__xmlele_type[key] - when :multi - org << value - org - when :single - @__xmlele_type[key] = :multi - [org, value] - else - raise RuntimeError.new("unknown type") - end - end -end - - -class MappingError < Error; end - - -class Registry - class Map - def initialize(registry) - @obj2soap = {} - @soap2obj = {} - @registry = registry - end - - def obj2soap(obj) - klass = obj.class - if map = @obj2soap[klass] - map.each do |soap_class, factory, info| - ret = factory.obj2soap(soap_class, obj, info, @registry) - 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] - map.each do |soap_class, factory, info| - if info[:derived_class] - ret = factory.obj2soap(soap_class, obj, info, @registry) - return ret if ret - end - end - end - end - nil - end - - def soap2obj(node, klass = nil) - if map = @soap2obj[node.class] - map.each do |obj_class, factory, info| - next if klass and obj_class != klass - conv, obj = factory.soap2obj(obj_class, node, info, @registry) - return true, obj if conv - end - end - return false, nil - end - - # Give priority to former entry. - def init(init_map = []) - clear - init_map.reverse_each do |obj_class, soap_class, factory, info| - add(obj_class, soap_class, factory, info) - end - end - - # Give priority to latter entry. - def add(obj_class, soap_class, factory, info) - info ||= {} - (@obj2soap[obj_class] ||= []).unshift([soap_class, factory, info]) - (@soap2obj[soap_class] ||= []).unshift([obj_class, factory, info]) - end - - def clear - @obj2soap.clear - @soap2obj.clear - end - - def find_mapped_soap_class(target_obj_class) - map = @obj2soap[target_obj_class] - map.empty? ? nil : map[0][1] - end - - def find_mapped_obj_class(target_soap_class) - map = @soap2obj[target_soap_class] - map.empty? ? nil : map[0][0] - end - end - - StringFactory = StringFactory_.new - BasetypeFactory = BasetypeFactory_.new - DateTimeFactory = DateTimeFactory_.new - ArrayFactory = ArrayFactory_.new - Base64Factory = Base64Factory_.new - URIFactory = URIFactory_.new - TypedArrayFactory = TypedArrayFactory_.new - TypedStructFactory = TypedStructFactory_.new - - HashFactory = HashFactory_.new - - SOAPBaseMap = [ - [::NilClass, ::SOAP::SOAPNil, BasetypeFactory], - [::TrueClass, ::SOAP::SOAPBoolean, BasetypeFactory], - [::FalseClass, ::SOAP::SOAPBoolean, BasetypeFactory], - [::String, ::SOAP::SOAPString, StringFactory], - [::DateTime, ::SOAP::SOAPDateTime, DateTimeFactory], - [::Date, ::SOAP::SOAPDate, DateTimeFactory], - [::Time, ::SOAP::SOAPDateTime, DateTimeFactory], - [::Time, ::SOAP::SOAPTime, DateTimeFactory], - [::Float, ::SOAP::SOAPDouble, BasetypeFactory, - {:derived_class => true}], - [::Float, ::SOAP::SOAPFloat, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPInt, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPLong, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPShort, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPByte, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNonPositiveInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNegativeInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNonNegativeInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPPositiveInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedLong, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedInt, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedShort, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedByte, BasetypeFactory, - {:derived_class => true}], - [::URI::Generic, ::SOAP::SOAPAnyURI, URIFactory, - {:derived_class => true}], - [::String, ::SOAP::SOAPBase64, Base64Factory], - [::String, ::SOAP::SOAPHexBinary, Base64Factory], - [::String, ::SOAP::SOAPDecimal, BasetypeFactory], - [::String, ::SOAP::SOAPDuration, BasetypeFactory], - [::String, ::SOAP::SOAPGYearMonth, BasetypeFactory], - [::String, ::SOAP::SOAPGYear, BasetypeFactory], - [::String, ::SOAP::SOAPGMonthDay, BasetypeFactory], - [::String, ::SOAP::SOAPGDay, BasetypeFactory], - [::String, ::SOAP::SOAPGMonth, BasetypeFactory], - [::String, ::SOAP::SOAPQName, BasetypeFactory], - - [::Hash, ::SOAP::SOAPArray, HashFactory], - [::Hash, ::SOAP::SOAPStruct, HashFactory], - - [::Array, ::SOAP::SOAPArray, ArrayFactory, - {:derived_class => true}], - - [::SOAP::Mapping::SOAPException, - ::SOAP::SOAPStruct, TypedStructFactory, - {:type => XSD::QName.new(RubyCustomTypeNamespace, "SOAPException")}], - ] - - RubyOriginalMap = [ - [::NilClass, ::SOAP::SOAPNil, BasetypeFactory], - [::TrueClass, ::SOAP::SOAPBoolean, BasetypeFactory], - [::FalseClass, ::SOAP::SOAPBoolean, BasetypeFactory], - [::String, ::SOAP::SOAPString, StringFactory], - [::DateTime, ::SOAP::SOAPDateTime, DateTimeFactory], - [::Date, ::SOAP::SOAPDate, DateTimeFactory], - [::Time, ::SOAP::SOAPDateTime, DateTimeFactory], - [::Time, ::SOAP::SOAPTime, DateTimeFactory], - [::Float, ::SOAP::SOAPDouble, BasetypeFactory, - {:derived_class => true}], - [::Float, ::SOAP::SOAPFloat, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPInt, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPLong, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPShort, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPByte, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNonPositiveInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNegativeInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPNonNegativeInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPPositiveInteger, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedLong, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedInt, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedShort, BasetypeFactory, - {:derived_class => true}], - [::Integer, ::SOAP::SOAPUnsignedByte, BasetypeFactory, - {:derived_class => true}], - [::URI::Generic, ::SOAP::SOAPAnyURI, URIFactory, - {:derived_class => true}], - [::String, ::SOAP::SOAPBase64, Base64Factory], - [::String, ::SOAP::SOAPHexBinary, Base64Factory], - [::String, ::SOAP::SOAPDecimal, BasetypeFactory], - [::String, ::SOAP::SOAPDuration, BasetypeFactory], - [::String, ::SOAP::SOAPGYearMonth, BasetypeFactory], - [::String, ::SOAP::SOAPGYear, BasetypeFactory], - [::String, ::SOAP::SOAPGMonthDay, BasetypeFactory], - [::String, ::SOAP::SOAPGDay, BasetypeFactory], - [::String, ::SOAP::SOAPGMonth, BasetypeFactory], - [::String, ::SOAP::SOAPQName, BasetypeFactory], - - [::Hash, ::SOAP::SOAPArray, HashFactory], - [::Hash, ::SOAP::SOAPStruct, HashFactory], - - # Does not allow Array's subclass here. - [::Array, ::SOAP::SOAPArray, ArrayFactory], - - [::SOAP::Mapping::SOAPException, - ::SOAP::SOAPStruct, TypedStructFactory, - {:type => XSD::QName.new(RubyCustomTypeNamespace, "SOAPException")}], - ] - - attr_accessor :default_factory - attr_accessor :excn_handler_obj2soap - attr_accessor :excn_handler_soap2obj - - def initialize(config = {}) - @config = config - @map = Map.new(self) - if @config[:allow_original_mapping] - @allow_original_mapping = true - @map.init(RubyOriginalMap) - else - @allow_original_mapping = false - @map.init(SOAPBaseMap) - end - @allow_untyped_struct = @config.key?(:allow_untyped_struct) ? - @config[:allow_untyped_struct] : true - @rubytype_factory = RubytypeFactory.new( - :allow_untyped_struct => @allow_untyped_struct, - :allow_original_mapping => @allow_original_mapping - ) - @default_factory = @rubytype_factory - @excn_handler_obj2soap = nil - @excn_handler_soap2obj = nil - end - - def add(obj_class, soap_class, factory, info = nil) - @map.add(obj_class, soap_class, factory, info) - end - alias set add - - # general Registry ignores type_qname - def obj2soap(obj, type_qname = nil) - soap = _obj2soap(obj) - if @allow_original_mapping - addextend2soap(soap, obj) - end - soap - end - - def soap2obj(node, klass = nil) - obj = _soap2obj(node, klass) - if @allow_original_mapping - addextend2obj(obj, node.extraattr[RubyExtendName]) - addiv2obj(obj, node.extraattr[RubyIVarName]) - end - obj - end - - def find_mapped_soap_class(obj_class) - @map.find_mapped_soap_class(obj_class) - end - - def find_mapped_obj_class(soap_class) - @map.find_mapped_obj_class(soap_class) - end - -private - - def _obj2soap(obj) - ret = nil - if obj.is_a?(SOAPStruct) or obj.is_a?(SOAPArray) - obj.replace do |ele| - Mapping._obj2soap(ele, self) - end - return obj - elsif obj.is_a?(SOAPBasetype) - return obj - end - begin - ret = @map.obj2soap(obj) || - @default_factory.obj2soap(nil, obj, nil, self) - return ret if ret - rescue MappingError - end - if @excn_handler_obj2soap - ret = @excn_handler_obj2soap.call(obj) { |yield_obj| - Mapping._obj2soap(yield_obj, self) - } - return ret if ret - end - raise MappingError.new("Cannot map #{ obj.class.name } to SOAP/OM.") - end - - # Might return nil as a mapping result. - def _soap2obj(node, klass = nil) - if node.extraattr.key?(RubyTypeName) - conv, obj = @rubytype_factory.soap2obj(nil, node, nil, self) - return obj if conv - else - conv, obj = @map.soap2obj(node, klass) - return obj if conv - conv, obj = @default_factory.soap2obj(nil, node, nil, self) - return obj if conv - 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.") - end - - def addiv2obj(obj, attr) - return unless attr - vars = {} - attr.__getobj__.each do |name, value| - vars[name] = Mapping._soap2obj(value, self) - end - Mapping.set_attributes(obj, vars) - end - - if RUBY_VERSION >= '1.8.0' - def addextend2obj(obj, attr) - return unless attr - attr.split(/ /).reverse_each do |mstr| - obj.extend(Mapping.module_from_name(mstr)) - end - end - else - # (class < false; self; end).ancestors includes "TrueClass" under 1.6... - def addextend2obj(obj, attr) - return unless attr - attr.split(/ /).reverse_each do |mstr| - m = Mapping.module_from_name(mstr) - obj.extend(m) - end - end - end - - def addextend2soap(node, obj) - return if obj.is_a?(Symbol) or obj.is_a?(Fixnum) - list = (class << obj; self; end).ancestors - obj.class.ancestors - unless list.empty? - node.extraattr[RubyExtendName] = list.collect { |c| - if c.name.empty? - raise TypeError.new("singleton can't be dumped #{ obj }") - end - c.name - }.join(" ") - end - end - -end - - -DefaultRegistry = Registry.new -RubyOriginalRegistry = Registry.new(:allow_original_mapping => true) - - -end -end diff --git a/ruby_1_8_6/lib/soap/mapping/rubytypeFactory.rb b/ruby_1_8_6/lib/soap/mapping/rubytypeFactory.rb deleted file mode 100644 index 61c21d8b20..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/rubytypeFactory.rb +++ /dev/null @@ -1,475 +0,0 @@ -# SOAP4R - Ruby type mapping factory. -# Copyright (C) 2000-2003, 2005 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 RubytypeFactory < Factory - TYPE_STRING = XSD::QName.new(RubyTypeNamespace, 'String') - TYPE_TIME = XSD::QName.new(RubyTypeNamespace, 'Time') - TYPE_ARRAY = XSD::QName.new(RubyTypeNamespace, 'Array') - TYPE_REGEXP = XSD::QName.new(RubyTypeNamespace, 'Regexp') - TYPE_RANGE = XSD::QName.new(RubyTypeNamespace, 'Range') - TYPE_CLASS = XSD::QName.new(RubyTypeNamespace, 'Class') - TYPE_MODULE = XSD::QName.new(RubyTypeNamespace, 'Module') - TYPE_SYMBOL = XSD::QName.new(RubyTypeNamespace, 'Symbol') - TYPE_STRUCT = XSD::QName.new(RubyTypeNamespace, 'Struct') - TYPE_HASH = XSD::QName.new(RubyTypeNamespace, 'Map') - - def initialize(config = {}) - @config = config - @allow_untyped_struct = @config.key?(:allow_untyped_struct) ? - @config[:allow_untyped_struct] : true - @allow_original_mapping = @config.key?(:allow_original_mapping) ? - @config[:allow_original_mapping] : false - @string_factory = StringFactory_.new(true) - @basetype_factory = BasetypeFactory_.new(true) - @datetime_factory = DateTimeFactory_.new(true) - @array_factory = ArrayFactory_.new(true) - @hash_factory = HashFactory_.new(true) - end - - def obj2soap(soap_class, obj, info, map) - param = nil - case obj - when ::String - unless @allow_original_mapping - return nil - end - param = @string_factory.obj2soap(SOAPString, obj, info, map) - if obj.class != String - param.extraattr[RubyTypeName] = obj.class.name - end - addiv2soapattr(param, obj, map) - when ::Time - unless @allow_original_mapping - return nil - end - param = @datetime_factory.obj2soap(SOAPDateTime, obj, info, map) - if obj.class != Time - param.extraattr[RubyTypeName] = obj.class.name - end - addiv2soapattr(param, obj, map) - when ::Array - unless @allow_original_mapping - return nil - end - param = @array_factory.obj2soap(nil, obj, info, map) - if obj.class != Array - param.extraattr[RubyTypeName] = obj.class.name - end - addiv2soapattr(param, obj, map) - when ::NilClass - unless @allow_original_mapping - return nil - end - param = @basetype_factory.obj2soap(SOAPNil, obj, info, map) - addiv2soapattr(param, obj, map) - when ::FalseClass, ::TrueClass - unless @allow_original_mapping - return nil - end - param = @basetype_factory.obj2soap(SOAPBoolean, obj, info, map) - addiv2soapattr(param, obj, map) - when ::Integer - unless @allow_original_mapping - return nil - end - param = @basetype_factory.obj2soap(SOAPInt, obj, info, map) - param ||= @basetype_factory.obj2soap(SOAPInteger, obj, info, map) - param ||= @basetype_factory.obj2soap(SOAPDecimal, obj, info, map) - addiv2soapattr(param, obj, map) - when ::Float - unless @allow_original_mapping - return nil - end - param = @basetype_factory.obj2soap(SOAPDouble, obj, info, map) - if obj.class != Float - param.extraattr[RubyTypeName] = obj.class.name - end - addiv2soapattr(param, obj, map) - when ::Hash - unless @allow_original_mapping - return nil - end - if obj.respond_to?(:default_proc) && obj.default_proc - raise TypeError.new("cannot dump hash with default proc") - end - param = SOAPStruct.new(TYPE_HASH) - mark_marshalled_obj(obj, param) - if obj.class != Hash - param.extraattr[RubyTypeName] = obj.class.name - end - obj.each do |key, value| - elem = SOAPStruct.new # Undefined type. - elem.add("key", Mapping._obj2soap(key, map)) - elem.add("value", Mapping._obj2soap(value, map)) - param.add("item", elem) - end - param.add('default', Mapping._obj2soap(obj.default, map)) - addiv2soapattr(param, obj, map) - when ::Regexp - unless @allow_original_mapping - return nil - end - param = SOAPStruct.new(TYPE_REGEXP) - mark_marshalled_obj(obj, param) - if obj.class != Regexp - param.extraattr[RubyTypeName] = obj.class.name - end - param.add('source', SOAPBase64.new(obj.source)) - if obj.respond_to?('options') - # Regexp#options is from Ruby/1.7 - options = obj.options - else - options = 0 - obj.inspect.sub(/^.*\//, '').each_byte do |c| - options += case c - when ?i - 1 - when ?x - 2 - when ?m - 4 - when ?n - 16 - when ?e - 32 - when ?s - 48 - when ?u - 64 - end - end - end - param.add('options', SOAPInt.new(options)) - addiv2soapattr(param, obj, map) - when ::Range - unless @allow_original_mapping - return nil - end - param = SOAPStruct.new(TYPE_RANGE) - mark_marshalled_obj(obj, param) - if obj.class != Range - param.extraattr[RubyTypeName] = obj.class.name - end - param.add('begin', Mapping._obj2soap(obj.begin, map)) - param.add('end', Mapping._obj2soap(obj.end, map)) - param.add('exclude_end', SOAP::SOAPBoolean.new(obj.exclude_end?)) - addiv2soapattr(param, obj, map) - when ::Class - unless @allow_original_mapping - return nil - end - if obj.to_s[0] == ?# - raise TypeError.new("can't dump anonymous class #{obj}") - end - param = SOAPStruct.new(TYPE_CLASS) - mark_marshalled_obj(obj, param) - param.add('name', SOAPString.new(obj.name)) - addiv2soapattr(param, obj, map) - when ::Module - unless @allow_original_mapping - return nil - end - if obj.to_s[0] == ?# - raise TypeError.new("can't dump anonymous module #{obj}") - end - param = SOAPStruct.new(TYPE_MODULE) - mark_marshalled_obj(obj, param) - param.add('name', SOAPString.new(obj.name)) - addiv2soapattr(param, obj, map) - when ::Symbol - unless @allow_original_mapping - return nil - end - param = SOAPStruct.new(TYPE_SYMBOL) - mark_marshalled_obj(obj, param) - param.add('id', SOAPString.new(obj.id2name)) - addiv2soapattr(param, obj, map) - when ::Struct - unless @allow_original_mapping - # treat it as an user defined class. [ruby-talk:104980] - #param = unknownobj2soap(soap_class, obj, info, map) - param = SOAPStruct.new(XSD::AnyTypeName) - mark_marshalled_obj(obj, param) - obj.members.each do |member| - param.add(Mapping.name2elename(member), - Mapping._obj2soap(obj[member], map)) - end - else - param = SOAPStruct.new(TYPE_STRUCT) - mark_marshalled_obj(obj, param) - param.add('type', ele_type = SOAPString.new(obj.class.to_s)) - ele_member = SOAPStruct.new - obj.members.each do |member| - ele_member.add(Mapping.name2elename(member), - Mapping._obj2soap(obj[member], map)) - end - param.add('member', ele_member) - addiv2soapattr(param, obj, map) - end - when ::IO, ::Binding, ::Continuation, ::Data, ::Dir, ::File::Stat, - ::MatchData, Method, ::Proc, ::Thread, ::ThreadGroup - # from 1.8: Process::Status, UnboundMethod - return nil - when ::SOAP::Mapping::Object - param = SOAPStruct.new(XSD::AnyTypeName) - mark_marshalled_obj(obj, param) - obj.__xmlele.each do |key, value| - param.add(key.name, Mapping._obj2soap(value, map)) - end - obj.__xmlattr.each do |key, value| - param.extraattr[key] = value - end - when ::Exception - typestr = Mapping.name2elename(obj.class.to_s) - param = SOAPStruct.new(XSD::QName.new(RubyTypeNamespace, typestr)) - mark_marshalled_obj(obj, param) - param.add('message', Mapping._obj2soap(obj.message, map)) - param.add('backtrace', Mapping._obj2soap(obj.backtrace, map)) - addiv2soapattr(param, obj, map) - else - param = unknownobj2soap(soap_class, obj, info, map) - end - param - end - - def soap2obj(obj_class, node, info, map) - rubytype = node.extraattr[RubyTypeName] - if rubytype or node.type.namespace == RubyTypeNamespace - rubytype2obj(node, info, map, rubytype) - elsif node.type == XSD::AnyTypeName or node.type == XSD::AnySimpleTypeName - anytype2obj(node, info, map) - else - unknowntype2obj(node, info, map) - end - end - -private - - def addiv2soapattr(node, obj, map) - return if obj.instance_variables.empty? - ivars = SOAPStruct.new # Undefined type. - setiv2soap(ivars, obj, map) - node.extraattr[RubyIVarName] = ivars - end - - def unknownobj2soap(soap_class, obj, info, map) - if obj.class.name.empty? - raise TypeError.new("can't dump anonymous class #{obj}") - end - singleton_class = class << obj; self; end - if !singleton_methods_true(obj).empty? or - !singleton_class.instance_variables.empty? - raise TypeError.new("singleton can't be dumped #{obj}") - end - if !(singleton_class.ancestors - obj.class.ancestors).empty? - typestr = Mapping.name2elename(obj.class.to_s) - type = XSD::QName.new(RubyTypeNamespace, typestr) - else - type = Mapping.class2element(obj.class) - end - param = SOAPStruct.new(type) - mark_marshalled_obj(obj, param) - setiv2soap(param, obj, map) - param - end - - if RUBY_VERSION >= '1.8.0' - def singleton_methods_true(obj) - obj.singleton_methods(true) - end - else - def singleton_methods_true(obj) - obj.singleton_methods - end - end - - def rubytype2obj(node, info, map, rubytype) - klass = rubytype ? Mapping.class_from_name(rubytype) : nil - obj = nil - case node - when SOAPString - return @string_factory.soap2obj(klass || String, node, info, map) - when SOAPDateTime - #return @datetime_factory.soap2obj(klass || Time, node, info, map) - klass ||= Time - t = node.to_time - arg = [t.year, t.month, t.mday, t.hour, t.min, t.sec, t.usec] - obj = t.gmt? ? klass.gm(*arg) : klass.local(*arg) - mark_unmarshalled_obj(node, obj) - return true, obj - when SOAPArray - return @array_factory.soap2obj(klass || Array, node, info, map) - when SOAPNil, SOAPBoolean, SOAPInt, SOAPInteger, SOAPDecimal, SOAPDouble - return @basetype_factory.soap2obj(nil, node, info, map) - when SOAPStruct - return rubytypestruct2obj(node, info, map, rubytype) - else - raise - end - end - - def rubytypestruct2obj(node, info, map, rubytype) - klass = rubytype ? Mapping.class_from_name(rubytype) : nil - obj = nil - case node.type - when TYPE_HASH - klass = rubytype ? Mapping.class_from_name(rubytype) : Hash - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - node.each do |key, value| - next unless key == 'item' - obj[Mapping._soap2obj(value['key'], map)] = - Mapping._soap2obj(value['value'], map) - end - if node.key?('default') - obj.default = Mapping._soap2obj(node['default'], map) - end - when TYPE_REGEXP - klass = rubytype ? Mapping.class_from_name(rubytype) : Regexp - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - source = node['source'].string - options = node['options'].data || 0 - Regexp.instance_method(:initialize).bind(obj).call(source, options) - when TYPE_RANGE - klass = rubytype ? Mapping.class_from_name(rubytype) : Range - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - first = Mapping._soap2obj(node['begin'], map) - last = Mapping._soap2obj(node['end'], map) - exclude_end = node['exclude_end'].data - Range.instance_method(:initialize).bind(obj).call(first, last, exclude_end) - when TYPE_CLASS - obj = Mapping.class_from_name(node['name'].data) - when TYPE_MODULE - obj = Mapping.class_from_name(node['name'].data) - when TYPE_SYMBOL - obj = node['id'].data.intern - when TYPE_STRUCT - typestr = Mapping.elename2name(node['type'].data) - klass = Mapping.class_from_name(typestr) - if klass.nil? - return false - end - unless klass <= ::Struct - return false - end - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - node['member'].each do |name, value| - obj[Mapping.elename2name(name)] = Mapping._soap2obj(value, map) - end - else - return unknowntype2obj(node, info, map) - end - return true, obj - end - - def anytype2obj(node, info, map) - case node - when SOAPBasetype - return true, node.data - when SOAPStruct - klass = ::SOAP::Mapping::Object - obj = klass.new - mark_unmarshalled_obj(node, obj) - node.each do |name, value| - obj.__add_xmlele_value(XSD::QName.new(nil, name), - Mapping._soap2obj(value, map)) - end - unless node.extraattr.empty? - obj.instance_variable_set('@__xmlattr', node.extraattr) - end - return true, obj - else - return false - end - end - - def unknowntype2obj(node, info, map) - case node - when SOAPBasetype - return true, node.data - when SOAPArray - return @array_factory.soap2obj(Array, node, info, map) - when SOAPStruct - obj = unknownstruct2obj(node, info, map) - return true, obj if obj - if !@allow_untyped_struct - return false - end - return anytype2obj(node, info, map) - else - # Basetype which is not defined... - return false - end - end - - def unknownstruct2obj(node, info, map) - unless node.type.name - return nil - end - typestr = Mapping.elename2name(node.type.name) - klass = Mapping.class_from_name(typestr) - if klass.nil? and @allow_untyped_struct - klass = Mapping.class_from_name(typestr, true) # lenient - end - if klass.nil? - return nil - end - if klass <= ::Exception - return exception2obj(klass, node, map) - end - klass_type = Mapping.class2qname(klass) - return nil unless node.type.match(klass_type) - obj = nil - begin - obj = Mapping.create_empty_object(klass) - rescue - # type name "data" tries Data.new which raises TypeError - nil - end - mark_unmarshalled_obj(node, obj) - setiv2obj(obj, node, map) - obj - end - - def exception2obj(klass, node, map) - message = Mapping._soap2obj(node['message'], map) - backtrace = Mapping._soap2obj(node['backtrace'], map) - obj = Mapping.create_empty_object(klass) - obj = obj.exception(message) - mark_unmarshalled_obj(node, obj) - obj.set_backtrace(backtrace) - obj - end - - # Only creates empty array. Do String#replace it with real string. - def array2obj(node, map, rubytype) - klass = rubytype ? Mapping.class_from_name(rubytype) : Array - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - obj - end - - # Only creates empty string. Do String#replace it with real string. - def string2obj(node, map, rubytype) - klass = rubytype ? Mapping.class_from_name(rubytype) : String - obj = Mapping.create_empty_object(klass) - mark_unmarshalled_obj(node, obj) - obj - end -end - - -end -end diff --git a/ruby_1_8_6/lib/soap/mapping/typeMap.rb b/ruby_1_8_6/lib/soap/mapping/typeMap.rb deleted file mode 100644 index 34db19a5b6..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/typeMap.rb +++ /dev/null @@ -1,50 +0,0 @@ -# SOAP4R - Base type mapping definition -# Copyright (C) 2000, 2001, 2002, 2003 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::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, - - SOAP::SOAPBase64::Type => SOAPBase64, -} - - -end diff --git a/ruby_1_8_6/lib/soap/mapping/wsdlencodedregistry.rb b/ruby_1_8_6/lib/soap/mapping/wsdlencodedregistry.rb deleted file mode 100644 index 4efb60188f..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/wsdlencodedregistry.rb +++ /dev/null @@ -1,280 +0,0 @@ -# SOAP4R - WSDL encoded mapping registry. -# Copyright (C) 2000-2003, 2005 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 < Registry - include TraverseSupport - - attr_reader :definedelements - attr_reader :definedtypes - attr_accessor :excn_handler_obj2soap - attr_accessor :excn_handler_soap2obj - - def initialize(definedtypes = XSD::NamedElements::Empty) - @definedtypes = definedtypes - # @definedelements = definedelements needed? - @excn_handler_obj2soap = nil - @excn_handler_soap2obj = nil - # For mapping AnyType element. - @rubytype_factory = RubytypeFactory.new( - :allow_untyped_struct => true, - :allow_original_mapping => true - ) - @schema_element_cache = {} - 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) - begin - return any2obj(node, obj_class) - rescue MappingError - 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") - end - -private - - def any2soap(obj, qname) - if obj.nil? - SOAPNil.new - elsif qname.nil? or qname == XSD::AnyTypeName - @rubytype_factory.obj2soap(nil, obj, nil, self) - elsif obj.is_a?(XSD::NSDBase) - soap2soap(obj, qname) - elsif (type = TypeMap[qname]) - base2soap(obj, type) - else - nil - end - 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.content.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. - o = base2soap(obj, TypeMap[type.base]) - o - 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 base2soap(obj, type) - soap_obj = nil - if type <= XSD::XSDString - str = XSD::Charset.encoding_conv(obj.to_s, - Thread.current[:SOAPExternalCES], XSD::Charset.encoding) - soap_obj = type.new(str) - mark_marshalled_obj(obj, soap_obj) - else - soap_obj = type.new(obj) - end - soap_obj - end - - def struct2soap(obj, type_qname, type) - return SOAPNil.new if obj.nil? # ToDo: check nillable. - soap_obj = SOAPStruct.new(type_qname) - unless obj.nil? - mark_marshalled_obj(obj, soap_obj) - elements2soap(obj, soap_obj, type.content.elements) - end - 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 - - def any2obj(node, obj_class) - unless obj_class - typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name) - obj_class = Mapping.class_from_name(typestr) - end - if obj_class and obj_class.class_variables.include?('@@schema_element') - soap2stubobj(node, obj_class) - else - Mapping._soap2obj(node, Mapping::DefaultRegistry, obj_class) - end - end - - def soap2stubobj(node, obj_class) - obj = Mapping.create_empty_object(obj_class) - unless node.is_a?(SOAPNil) - add_elements2stubobj(node, obj) - end - obj - end - - def add_elements2stubobj(node, obj) - elements, as_array = schema_element_definition(obj.class) - vars = {} - node.each do |name, value| - item = elements.find { |k, v| k.name == name } - if item - elename, class_name = item - if klass = Mapping.class_from_name(class_name) - # klass must be a SOAPBasetype or a class - if klass.ancestors.include?(::SOAP::SOAPBasetype) - if value.respond_to?(:data) - child = klass.new(value.data).data - else - child = klass.new(nil).data - end - else - child = Mapping._soap2obj(value, self, klass) - end - elsif klass = Mapping.module_from_name(class_name) - # simpletype - if value.respond_to?(:data) - child = value.data - else - raise MappingError.new( - "cannot map to a module value: #{class_name}") - end - else - raise MappingError.new("unknown class: #{class_name}") - end - else # untyped element is treated as anyType. - child = Mapping._soap2obj(value, self) - end - vars[name] = child - end - Mapping.set_attributes(obj, vars) - end - - # it caches @@schema_element. this means that @@schema_element must not be - # changed while a lifetime of a WSDLLiteralRegistry. - def schema_element_definition(klass) - @schema_element_cache[klass] ||= Mapping.schema_element_definition(klass) - end -end - - -end -end diff --git a/ruby_1_8_6/lib/soap/mapping/wsdlliteralregistry.rb b/ruby_1_8_6/lib/soap/mapping/wsdlliteralregistry.rb deleted file mode 100644 index 7bb8e12203..0000000000 --- a/ruby_1_8_6/lib/soap/mapping/wsdlliteralregistry.rb +++ /dev/null @@ -1,418 +0,0 @@ -# SOAP4R - WSDL literal mapping registry. -# Copyright (C) 2004, 2005 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 WSDLLiteralRegistry < Registry - attr_reader :definedelements - attr_reader :definedtypes - attr_accessor :excn_handler_obj2soap - attr_accessor :excn_handler_soap2obj - - def initialize(definedtypes = XSD::NamedElements::Empty, - definedelements = XSD::NamedElements::Empty) - @definedtypes = definedtypes - @definedelements = definedelements - @excn_handler_obj2soap = nil - @excn_handler_soap2obj = nil - @schema_element_cache = {} - @schema_attribute_cache = {} - end - - def obj2soap(obj, qname) - soap_obj = nil - if ele = @definedelements[qname] - soap_obj = obj2elesoap(obj, ele) - elsif type = @definedtypes[qname] - soap_obj = obj2typesoap(obj, type, true) - 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, 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) - # obj_class is given when rpc/literal service. but ignored for now. - begin - return any2obj(node) - rescue MappingError - 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 - if node.respond_to?(:type) - raise MappingError.new("cannot map #{node.type.name} to Ruby object") - else - raise MappingError.new("cannot map #{node.elename.name} to Ruby object") - end - end - -private - - MAPPING_OPT = { :no_reference => true } - - def obj2elesoap(obj, ele) - o = nil - qualified = (ele.elementform == 'qualified') - if ele.type - if type = @definedtypes[ele.type] - o = obj2typesoap(obj, type, qualified) - elsif type = TypeMap[ele.type] - o = base2soap(obj, type) - else - raise MappingError.new("cannot find type #{ele.type}") - end - elsif ele.local_complextype - o = obj2typesoap(obj, ele.local_complextype, qualified) - add_attributes2soap(obj, o) - elsif ele.local_simpletype - o = obj2typesoap(obj, ele.local_simpletype, qualified) - else - raise MappingError.new('illegal schema?') - end - o.elename = ele.name - o - end - - def obj2typesoap(obj, type, qualified) - if type.is_a?(::WSDL::XMLSchema::SimpleType) - simpleobj2soap(obj, type) - else - complexobj2soap(obj, type, qualified) - end - end - - def simpleobj2soap(obj, type) - type.check_lexical_format(obj) - return SOAPNil.new if obj.nil? # ToDo: check nillable. - o = base2soap(obj, TypeMap[type.base]) - o - end - - def complexobj2soap(obj, type, qualified) - o = SOAPElement.new(type.name) - o.qualified = qualified - type.each_element do |child_ele| - child = Mapping.get_attribute(obj, child_ele.name.name) - if child.nil? - if child_ele.nillable - # ToDo: test - # add empty element - child_soap = obj2elesoap(nil, child_ele) - o.add(child_soap) - elsif Integer(child_ele.minoccurs) == 0 - # nothing to do - else - raise MappingError.new("nil not allowed: #{child_ele.name.name}") - end - elsif child_ele.map_as_array? - child.each do |item| - child_soap = obj2elesoap(item, child_ele) - o.add(child_soap) - end - else - child_soap = obj2elesoap(child, child_ele) - o.add(child_soap) - end - end - o - end - - def any2soap(obj, qname) - if obj.is_a?(SOAPElement) - obj - elsif obj.class.class_variables.include?('@@schema_element') - stubobj2soap(obj, qname) - elsif obj.is_a?(SOAP::Mapping::Object) - mappingobj2soap(obj, qname) - elsif obj.is_a?(Hash) - ele = SOAPElement.from_obj(obj) - ele.elename = qname - ele - 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 - ele - rescue MappingError - ele = SOAPElement.new(qname, obj.to_s) - end - if obj.respond_to?(:__xmlattr) - obj.__xmlattr.each do |key, value| - ele.extraattr[key] = value - end - end - ele - end - end - - def stubobj2soap(obj, qname) - ele = SOAPElement.new(qname) - ele.qualified = - (obj.class.class_variables.include?('@@schema_qualified') and - obj.class.class_eval('@@schema_qualified')) - add_elements2soap(obj, ele) - add_attributes2soap(obj, ele) - ele - 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 add_elements2soap(obj, ele) - elements, as_array = schema_element_definition(obj.class) - if elements - elements.each do |elename, type| - if child = Mapping.get_attribute(obj, elename.name) - if as_array.include?(elename.name) - child.each do |item| - ele.add(obj2soap(item, elename)) - end - else - ele.add(obj2soap(child, elename)) - end - elsif obj.is_a?(::Array) and as_array.include?(elename.name) - obj.each do |item| - ele.add(obj2soap(item, elename)) - end - end - end - end - end - - def add_attributes2soap(obj, ele) - attributes = schema_attribute_definition(obj.class) - if attributes - attributes.each do |qname, param| - attr = obj.__send__('xmlattr_' + - XSD::CodeGen::GenSupport.safevarname(qname.name)) - ele.extraattr[qname] = attr - end - end - end - - def base2soap(obj, type) - soap_obj = nil - if type <= XSD::XSDString - str = XSD::Charset.encoding_conv(obj.to_s, - Thread.current[:SOAPExternalCES], XSD::Charset.encoding) - soap_obj = type.new(str) - else - soap_obj = type.new(obj) - end - soap_obj - end - - def anytype2obj(node) - if node.is_a?(::SOAP::SOAPBasetype) - return node.data - end - klass = ::SOAP::Mapping::Object - obj = klass.new - obj - end - - def any2obj(node, obj_class = nil) - unless obj_class - typestr = XSD::CodeGen::GenSupport.safeconstname(node.elename.name) - obj_class = Mapping.class_from_name(typestr) - end - if obj_class and obj_class.class_variables.include?('@@schema_element') - soapele2stubobj(node, obj_class) - elsif node.is_a?(SOAPElement) or node.is_a?(SOAPStruct) - # SOAPArray for literal? - soapele2plainobj(node) - else - obj = Mapping.soap2obj(node, nil, obj_class, MAPPING_OPT) - add_attributes2plainobj(node, obj) - obj - end - end - - def soapele2stubobj(node, obj_class) - obj = Mapping.create_empty_object(obj_class) - add_elements2stubobj(node, obj) - add_attributes2stubobj(node, obj) - obj - end - - def soapele2plainobj(node) - obj = anytype2obj(node) - add_elements2plainobj(node, obj) - add_attributes2plainobj(node, obj) - obj - end - - def add_elements2stubobj(node, obj) - elements, as_array = schema_element_definition(obj.class) - vars = {} - node.each do |name, value| - item = elements.find { |k, v| k.name == name } - if item - elename, class_name = item - if klass = Mapping.class_from_name(class_name) - # klass must be a SOAPBasetype or a class - if klass.ancestors.include?(::SOAP::SOAPBasetype) - if value.respond_to?(:data) - child = klass.new(value.data).data - else - child = klass.new(nil).data - end - else - child = any2obj(value, klass) - end - elsif klass = Mapping.module_from_name(class_name) - # simpletype - if value.respond_to?(:data) - child = value.data - else - raise MappingError.new( - "cannot map to a module value: #{class_name}") - end - else - raise MappingError.new("unknown class/module: #{class_name}") - end - else # untyped element is treated as anyType. - child = any2obj(value) - end - if as_array.include?(elename.name) - (vars[name] ||= []) << child - else - vars[name] = child - end - end - Mapping.set_attributes(obj, vars) - end - - def add_attributes2stubobj(node, obj) - if attributes = schema_attribute_definition(obj.class) - define_xmlattr(obj) - attributes.each do |qname, class_name| - attr = node.extraattr[qname] - next if attr.nil? or attr.empty? - klass = Mapping.class_from_name(class_name) - if klass.ancestors.include?(::SOAP::SOAPBasetype) - child = klass.new(attr).data - else - child = attr - end - obj.__xmlattr[qname] = child - define_xmlattr_accessor(obj, qname) - end - end - end - - def add_elements2plainobj(node, obj) - node.each do |name, value| - obj.__add_xmlele_value(value.elename, any2obj(value)) - end - end - - def add_attributes2plainobj(node, obj) - return if node.extraattr.empty? - define_xmlattr(obj) - node.extraattr.each do |qname, value| - obj.__xmlattr[qname] = value - define_xmlattr_accessor(obj, qname) - end - end - - if RUBY_VERSION > "1.7.0" - def define_xmlattr_accessor(obj, qname) - name = XSD::CodeGen::GenSupport.safemethodname(qname.name) - Mapping.define_attr_accessor(obj, 'xmlattr_' + name, - proc { @__xmlattr[qname] }, - proc { |value| @__xmlattr[qname] = value }) - end - else - def define_xmlattr_accessor(obj, qname) - name = XSD::CodeGen::GenSupport.safemethodname(qname.name) - obj.instance_eval <<-EOS - def #{name} - @__xmlattr[#{qname.dump}] - end - - def #{name}=(value) - @__xmlattr[#{qname.dump}] = value - end - EOS - end - end - - if RUBY_VERSION > "1.7.0" - def define_xmlattr(obj) - obj.instance_variable_set('@__xmlattr', {}) - unless obj.respond_to?(:__xmlattr) - Mapping.define_attr_accessor(obj, :__xmlattr, proc { @__xmlattr }) - end - end - else - 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 - - # it caches @@schema_element. this means that @@schema_element must not be - # changed while a lifetime of a WSDLLiteralRegistry. - def schema_element_definition(klass) - @schema_element_cache[klass] ||= Mapping.schema_element_definition(klass) - end - - def schema_attribute_definition(klass) - @schema_attribute_cache[klass] ||= Mapping.schema_attribute_definition(klass) - end -end - - -end -end |