* collapse 'ws' back into protocols, it just added complexity and indirection, and was hard to extend.

* extract casting into seperate support file
* ensure casting always does the right thing for return values, should fix interoperability issues with Ecto and possibly other XML-RPC clients
* add functional unit tests for scaffolding
* represent signature items with classes instead of symbols/Class objects, much more flexible
* tweak logging to always show casted versions of parameters and return values, if possible.


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

1 files changed, 0 insertions, 143 deletions

diff --git a/actionwebservice/lib/action_web_service/vendor/ws/marshaling/xmlrpc_marshaling.rb b/actionwebservice/lib/action_web_service/vendor/ws/marshaling/xmlrpc_marshaling.rb
deleted file mode 100644
index 56cc7597fb..0000000000
--- a/actionwebservice/lib/action_web_service/vendor/ws/marshaling/xmlrpc_marshaling.rb
+++ /dev/null
@@ -1,143 +0,0 @@
-module WS
-  module Marshaling
-    class XmlRpcError < WSError
-    end
-
-    class XmlRpcMarshaler < AbstractMarshaler
-      def initialize
-        super()
-        @spec2binding = {}
-      end
-
-      def marshal(param)
-        value = param.value
-        cast_outbound_recursive(param.value, spec_for(param)) rescue value
-      end
-
-      def unmarshal(obj)
-        obj.param
-      end
-
-      def typed_unmarshal(obj, spec)
-        obj.param.info.data = lookup_type(spec)
-        value = obj.param.value
-        obj.param.value = cast_inbound_recursive(value, spec) rescue value
-        obj.param
-      end
-
-      def register_type(spec)
-        if @spec2binding.has_key?(spec)
-          return @spec2binding[spec]
-        end
-
-        klass = BaseTypes.canonical_param_type_class(spec)
-        type_binding = nil
-        if klass.is_a?(Array)
-          type_binding = XmlRpcArrayBinding.new(klass[0])
-        else
-          type_binding = XmlRpcBinding.new(klass)
-        end
-
-        @spec2binding[spec] = type_binding
-      end
-      alias :lookup_type :register_type
-
-      def cast_inbound_recursive(value, spec)
-        binding = lookup_type(spec)
-        case binding
-        when XmlRpcArrayBinding
-          value.map{ |x| cast_inbound(x, binding.element_klass) }
-        when XmlRpcBinding
-          cast_inbound(value, binding.klass)
-        end
-      end
-
-      def cast_outbound_recursive(value, spec)
-        binding = lookup_type(spec)
-        case binding
-        when XmlRpcArrayBinding
-          value.map{ |x| cast_outbound(x, binding.element_klass) }
-        when XmlRpcBinding
-          cast_outbound(value, binding.klass)
-        end
-      end
-
-      private
-        def spec_for(param)
-          binding = param.info.data
-          binding.is_a?(XmlRpcArrayBinding) ? [binding.element_klass] : binding.klass
-        end
-
-        def cast_inbound(value, klass)
-          if BaseTypes.base_type?(klass)
-            value = value.to_time if value.is_a?(XMLRPC::DateTime)
-            base_type_caster.cast(value, klass)
-          elsif value.is_a?(XMLRPC::FaultException)
-            value
-          elsif klass.ancestors.include?(ActionWebService::Struct)
-            obj = klass.new
-            klass.members.each do |name, klass|
-              name = name.to_s
-              obj.send('%s=' % name, cast_inbound_recursive(value[name], klass))
-            end
-            obj
-          else
-            obj = klass.new
-            if obj.respond_to?(:update)
-              obj.update(value)
-            else
-              value.each do |name, val|
-                obj.send('%s=' % name.to_s, val)
-              end
-            end
-            obj
-          end
-        end
-
-        def cast_outbound(value, klass)
-          if BaseTypes.base_type?(klass)
-            base_type_caster.cast(value, klass)
-          elsif value.is_a?(Exception)
-            XMLRPC::FaultException.new(2, value.message)
-          elsif Object.const_defined?('ActiveRecord') && value.is_a?(ActiveRecord::Base)
-            value.attributes
-          elsif value.is_a?(ActionWebService::Struct)
-            struct = {}
-            value.class.members.each do |name, klass|
-              name = name.to_s
-              struct[name] = cast_outbound_recursive(value[name], klass)
-            end
-            struct
-          else
-            struct = {}
-            if value.respond_to?(:each_pair)
-              value.each_pair{ |key, value| struct[key] = value }
-            else
-              value.instance_variables.each do |name|
-                key = name.sub(/^@/, '')
-                struct[key] = value.instance_variable_get(name)
-              end
-            end
-            struct
-          end
-        end
-    end
-
-    class XmlRpcBinding
-      attr :klass
-      
-      def initialize(klass)
-        @klass = klass
-      end
-    end
-
-    class XmlRpcArrayBinding < XmlRpcBinding
-      attr :element_klass
-
-      def initialize(element_klass)
-        super(Array)
-        @element_klass = element_klass
-      end
-    end
-  end
-end