Ousted ActionWebService from Rails 2.0

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@8180 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

1 files changed, 0 insertions, 235 deletions

diff --git a/actionwebservice/lib/action_web_service/protocol/soap_protocol/marshaler.rb b/actionwebservice/lib/action_web_service/protocol/soap_protocol/marshaler.rb
deleted file mode 100644
index 1873396277..0000000000
--- a/actionwebservice/lib/action_web_service/protocol/soap_protocol/marshaler.rb
+++ /dev/null
@@ -1,235 +0,0 @@
-require 'soap/mapping'
-
-module ActionWebService
-  module Protocol
-    module Soap
-      # Workaround for SOAP4R return values changing
-      class Registry < SOAP::Mapping::Registry
-        if SOAP::Version >= "1.5.4"
-          def find_mapped_soap_class(obj_class)
-            return @map.instance_eval { @obj2soap[obj_class][0] }
-          end
-
-          def find_mapped_obj_class(soap_class)
-            return @map.instance_eval { @soap2obj[soap_class][0] }
-          end
-        end
-      end
-
-      class SoapMarshaler
-        attr :namespace
-        attr :registry
-
-        def initialize(namespace=nil)
-          @namespace = namespace || 'urn:ActionWebService'
-          @registry = Registry.new
-          @type2binding = {}
-          register_static_factories
-        end
-
-        def soap_to_ruby(obj)
-          SOAP::Mapping.soap2obj(obj, @registry)
-        end
-
-        def ruby_to_soap(obj)
-          soap = SOAP::Mapping.obj2soap(obj, @registry)
-          soap.elename = XSD::QName.new if SOAP::Version >= "1.5.5" && soap.elename == XSD::QName::EMPTY
-          soap
-        end
-
-        def register_type(type)
-          return @type2binding[type] if @type2binding.has_key?(type)
-
-          if type.array?
-            array_mapping = @registry.find_mapped_soap_class(Array)
-            qname = XSD::QName.new(@namespace, soap_type_name(type.element_type.type_class.name) + 'Array')
-            element_type_binding = register_type(type.element_type)
-            @type2binding[type] = SoapBinding.new(self, qname, type, array_mapping, element_type_binding)
-          elsif (mapping = @registry.find_mapped_soap_class(type.type_class) rescue nil)
-            qname = mapping[2] ? mapping[2][:type] : nil
-            qname ||= soap_base_type_name(mapping[0])
-            @type2binding[type] = SoapBinding.new(self, qname, type, mapping)
-          else
-            qname = XSD::QName.new(@namespace, soap_type_name(type.type_class.name))
-            @registry.add(type.type_class,
-              SOAP::SOAPStruct,
-              typed_struct_factory(type.type_class),
-              { :type => qname })
-            mapping = @registry.find_mapped_soap_class(type.type_class)
-            @type2binding[type] = SoapBinding.new(self, qname, type, mapping)
-          end
-
-          if type.structured?
-            type.each_member do |m_name, m_type|
-              register_type(m_type)
-            end
-          end
-          
-          @type2binding[type]
-        end
-        alias :lookup_type :register_type
-
-        def annotate_arrays(binding, value)
-          if value.nil?
-            return
-          elsif binding.type.array?
-            mark_typed_array(value, binding.element_binding.qname)
-            if binding.element_binding.type.custom?
-              value.each do |element|
-                annotate_arrays(binding.element_binding, element)
-              end
-            end
-          elsif binding.type.structured?
-            binding.type.each_member do |name, type|
-              member_binding = register_type(type)
-              member_value = value.respond_to?('[]') ? value[name] : value.send(name)
-              annotate_arrays(member_binding, member_value) if type.custom?
-            end
-          end
-        end
-
-        private
-          def typed_struct_factory(type_class)
-            if Object.const_defined?('ActiveRecord')
-              if type_class.ancestors.include?(ActiveRecord::Base)
-                qname =  XSD::QName.new(@namespace, soap_type_name(type_class.name))
-                type_class.instance_variable_set('@qname', qname)
-                return SoapActiveRecordStructFactory.new
-              end
-            end
-            SOAP::Mapping::Registry::TypedStructFactory
-          end
-
-          def mark_typed_array(array, qname)
-            (class << array; self; end).class_eval do 
-              define_method(:arytype) do
-                qname
-              end
-            end
-          end
-
-          def soap_base_type_name(type)
-            xsd_type = type.ancestors.find{ |c| c.const_defined? 'Type' }
-            xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
-          end
-
-          def soap_type_name(type_name)
-            type_name.gsub(/::/, '..')
-          end
-
-          def register_static_factories
-            @registry.add(ActionWebService::Base64, SOAP::SOAPBase64, SoapBase64Factory.new, nil)
-            mapping = @registry.find_mapped_soap_class(ActionWebService::Base64)
-            @type2binding[ActionWebService::Base64] =
-              SoapBinding.new(self, SOAP::SOAPBase64::Type, ActionWebService::Base64, mapping)
-            @registry.add(Array, SOAP::SOAPArray, SoapTypedArrayFactory.new, nil)
-            @registry.add(::BigDecimal, SOAP::SOAPDouble, SOAP::Mapping::Registry::BasetypeFactory, {:derived_class => true})
-          end
-      end
-
-      class SoapBinding
-        attr :qname
-        attr :type
-        attr :mapping
-        attr :element_binding
-
-        def initialize(marshaler, qname, type, mapping, element_binding=nil)
-          @marshaler = marshaler
-          @qname = qname
-          @type = type
-          @mapping = mapping
-          @element_binding = element_binding
-        end
-
-        def type_name
-          @type.custom? ? @qname.name : nil
-        end
-
-        def qualified_type_name(ns=nil)
-          if @type.custom?
-            "#{ns ? ns : @qname.namespace}:#{@qname.name}"
-          else
-            ns = XSD::NS.new
-            ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
-            ns.assign(SOAP::EncodingNamespace, "soapenc")
-            xsd_klass = mapping[0].ancestors.find{|c| c.const_defined?('Type')}
-            return ns.name(XSD::AnyTypeName) unless xsd_klass
-            ns.name(xsd_klass.const_get('Type'))
-          end
-        end
-
-        def eql?(other)
-          @qname == other.qname
-        end
-        alias :== :eql?
-
-        def hash
-          @qname.hash
-        end
-      end
-
-      class SoapActiveRecordStructFactory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.is_a?(ActiveRecord::Base)
-            return nil
-          end
-          soap_obj = soap_class.new(obj.class.instance_variable_get('@qname'))
-          obj.class.columns.each do |column|
-            key = column.name.to_s
-            value = obj.send(key)
-            soap_obj[key] = SOAP::Mapping._obj2soap(value, map)
-          end
-          soap_obj
-        end
-
-        def soap2obj(obj_class, node, info, map)
-          unless node.type == obj_class.instance_variable_get('@qname')
-            return false
-          end
-          obj = obj_class.new
-          node.each do |key, value|
-            obj[key] = value.data
-          end
-          obj.instance_variable_set('@new_record', false)
-          return true, obj
-        end
-      end
-
-      class SoapTypedArrayFactory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.respond_to?(:arytype)
-            return nil
-          end
-          soap_obj = soap_class.new(SOAP::ValueArrayName, 1, obj.arytype)
-          mark_marshalled_obj(obj, soap_obj)
-          obj.each do |item|
-            child = SOAP::Mapping._obj2soap(item, map)
-            soap_obj.add(child)
-          end
-          soap_obj
-        end
-      
-        def soap2obj(obj_class, node, info, map)
-          return false
-        end
-      end
-
-      class SoapBase64Factory < SOAP::Mapping::Factory
-        def obj2soap(soap_class, obj, info, map)
-          unless obj.is_a?(ActionWebService::Base64)
-            return nil
-          end
-          return soap_class.new(obj)
-        end
-
-        def soap2obj(obj_class, node, info, map)
-          unless node.type == SOAP::SOAPBase64::Type
-            return false
-          end
-          return true, obj_class.new(node.string)
-        end
-      end
-
-    end
-  end
-end