actionwebservice 0.5.0 → 0.6.0

data/lib/action_web_service/protocol/xmlrpc_protocol.rb

@@ -1,167 +1,47 @@
-require 'xmlrpc/parser'
-require 'xmlrpc/create'
-require 'xmlrpc/config'
-require 'xmlrpc/utils'
-require 'singleton'
-
-module XMLRPC # :nodoc:
-  class XmlRpcHelper # :nodoc:
-    include Singleton
-    include ParserWriterChooseMixin
-
-    def parse_method_call(message)
-      parser().parseMethodCall(message)
-    end
-
-    def create_method_response(successful, return_value)
-      create().methodResponse(successful, return_value)
-    end
-  end
-end
-
 module ActionWebService # :nodoc:
   module Protocol # :nodoc:
     module XmlRpc # :nodoc:
-      def self.append_features(base) # :nodoc:
-        super
-        base.register_protocol(BodyOnly, XmlRpcProtocol)
+      def self.included(base)
+        base.register_protocol(XmlRpcProtocol)
       end
+      
+      class XmlRpcProtocol # :nodoc:
+        attr :marshaler
 
-      class XmlRpcProtocol < AbstractProtocol # :nodoc:
-        def self.create_protocol_request(container_class, action_pack_request)
-          helper = XMLRPC::XmlRpcHelper.instance
-          service_name = action_pack_request.parameters['action']
-          methodname, params = helper.parse_method_call(action_pack_request.raw_post)
-          methodname.gsub!(/^[^\.]+\./, '') unless methodname =~ /^system\./ # XXX
-          protocol = XmlRpcProtocol.new(container_class)
-          content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
-          content_type ||= 'text/xml'
-          request = ProtocolRequest.new(protocol,
-                                        action_pack_request.raw_post,
-                                        service_name.to_sym,
-                                        methodname,
-                                        content_type,
-                                        :xmlrpc_values => params)
-          request
-        rescue
-          nil
-        end
-
-        def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
-          return nil unless protocol_name.to_s.downcase.to_sym == :xmlrpc
-          ActionWebService::Client::XmlRpc.new(api, endpoint_uri, options)
+        def initialize
+          @encoder = WS::Encoding::XmlRpcEncoding.new
+          @marshaler = WS::Marshaling::XmlRpcMarshaler.new
         end
 
-        def initialize(container_class)
-          super(container_class)
+        def unmarshal_request(ap_request)
+          method_name, params = @encoder.decode_rpc_call(ap_request.raw_post)
+          params = params.map{|x| @marshaler.unmarshal(x)}
+          service_name = ap_request.parameters['action']
+          Request.new(self, method_name, params, service_name)
+        rescue
+          nil
         end
 
-        def unmarshal_request(protocol_request)
-          values = protocol_request.options[:xmlrpc_values]
-          signature = protocol_request.signature
-          if signature
-            values = self.class.transform_incoming_method_params(self.class.transform_array_types(signature), values)
-            protocol_request.check_parameter_types(values, check_array_types(signature))
-            values
-          else
-            protocol_request.checked? ? [] : values
-          end
-        end
-  
-        def marshal_response(protocol_request, return_value)
-          helper = XMLRPC::XmlRpcHelper.instance
-          signature = protocol_request.return_signature
-          if signature
-            protocol_request.check_parameter_types([return_value], check_array_types(signature))
-            return_value = self.class.transform_return_value(self.class.transform_array_types(signature), return_value)
-            raw_response = helper.create_method_response(true, return_value)
+        def marshal_response(method_name, return_value, signature_type)
+          if !return_value.nil? && signature_type
+            type_binding = @marshaler.register_type(signature_type)
+            info = WS::ParamInfo.create(signature_type, type_binding, 0)
+            return_value = @marshaler.marshal(WS::Param.new(return_value, info))
           else
-            # XML-RPC doesn't have the concept of a void method, nor does it
-            # support a nil return value, so return true if we would have returned
-            # nil
-            if protocol_request.checked?
-              raw_response = helper.create_method_response(true, true)
-            else
-              return_value = true if return_value.nil?
-              raw_response = helper.create_method_response(true, return_value)
-            end
+            return_value = nil
           end
-          ProtocolResponse.new(self, raw_response, 'text/xml')
+          body = @encoder.encode_rpc_response(method_name, return_value)
+          Response.new(body, 'text/xml')
         end
-  
-        def marshal_exception(exception)
-          helper = XMLRPC::XmlRpcHelper.instance
-          exception = XMLRPC::FaultException.new(1, exception.message)
-          raw_response = helper.create_method_response(false, exception)
-          ProtocolResponse.new(self, raw_response, 'text/xml')
-        end
-
-        class << self
-          def transform_incoming_method_params(signature, params)
-            (1..signature.size).each do |i|
-              i -= 1
-              params[i] = xmlrpc_to_ruby(params[i], signature[i])
-            end
-            params
-          end
-
-          def transform_return_value(signature, return_value)
-            ruby_to_xmlrpc(return_value, signature[0])
-          end
-
-          def ruby_to_xmlrpc(param, param_class)
-            if param_class.is_a?(XmlRpcArray)
-              param.map{|p| ruby_to_xmlrpc(p, param_class.klass)}
-            elsif param_class.ancestors.include?(ActiveRecord::Base)
-              param.instance_variable_get('@attributes')
-            elsif param_class.ancestors.include?(ActionWebService::Struct)
-              struct = {}
-              param_class.members.each do |name, klass|
-                value = param.send(name)
-                next if value.nil?
-                struct[name.to_s] = value
-              end
-              struct
-            else
-              param
-            end
-          end
 
-          def xmlrpc_to_ruby(param, param_class)
-            if param_class.is_a?(XmlRpcArray)
-              param.map{|p| xmlrpc_to_ruby(p, param_class.klass)}
-            elsif param_class.ancestors.include?(ActiveRecord::Base)
-              raise(ProtocolError, "incoming ActiveRecord::Base types are not allowed")
-            elsif param_class.ancestors.include?(ActionWebService::Struct)
-              unless param.is_a?(Hash)
-                raise(ProtocolError, "expected parameter to be a Hash")
-              end
-              new_param = param_class.new
-              param_class.members.each do |name, klass|
-                new_param.send('%s=' % name.to_s, param[name.to_s])
-              end
-              new_param
-            else
-              param
-            end
-          end
+        def register_signature_type(spec)
+          nil
+        end
 
-          def transform_array_types(signature)
-            signature.map{|x| x.is_a?(Array) ? XmlRpcArray.new(x[0]) : x}
-          end
+        def protocol_client(api, protocol_name, endpoint_uri, options)
+          return nil unless protocol_name == :xmlrpc
+          ActionWebService::Client::XmlRpc.new(api, endpoint_uri, options)
         end
-  
-        private
-          def check_array_types(signature)
-            signature.map{|x| x.is_a?(Array) ? Array : x}
-          end
-          
-          class XmlRpcArray
-            attr :klass
-            def initialize(klass)
-              @klass = klass
-            end
-          end
       end
     end
   end

data/lib/action_web_service/struct.rb

@@ -17,8 +17,7 @@ module ActionWebService
   #   person = Person.new(:id => 5, :firstname => 'john', :lastname => 'doe')
   #
   # Active Record model classes are already implicitly supported for method
-  # return signatures. A structure containing its columns as members will be
-  # automatically generated if its present in a signature.
+  # return signatures.
   class Struct
     
     # If a Hash is given as argument to an ActionWebService::Struct constructor,
@@ -35,12 +34,10 @@ module ActionWebService
     end
 
     class << self
-      include ActionWebService::Signature
-
       # Creates a structure member with the specified +name+ and +type+. Generates
       # accessor methods for reading and writing the member value.
       def member(name, type)
-        write_inheritable_hash("struct_members", name => signature_parameter_class(type))
+        write_inheritable_hash("struct_members", name => WS::BaseTypes.canonical_param_type_class(type))
         class_eval <<-END
           def #{name}; @#{name}; end
           def #{name}=(value); @#{name} = value; end

data/lib/action_web_service/test_invoke.rb

@@ -0,0 +1,130 @@
+require 'test/unit'
+
+module Test
+  module Unit
+    class TestCase # :nodoc:
+      private
+        # invoke the specified API method
+        def invoke_direct(method_name, *args)
+          prepare_request('api', 'api', method_name, *args)
+          @controller.process(@request, @response)
+          decode_rpc_response
+        end
+        alias_method :invoke, :invoke_direct
+
+        # invoke the specified API method on the specified service
+        def invoke_delegated(service_name, method_name, *args)
+          prepare_request(service_name.to_s, service_name, method_name, *args)
+          @controller.process(@request, @response)
+          decode_rpc_response
+        end
+
+        # invoke the specified layered API method on the correct service
+        def invoke_layered(service_name, method_name, *args)
+          if protocol == :soap
+            raise "SOAP protocol support for :layered dispatching mode is not available"
+          end
+          prepare_request('api', service_name, method_name, *args)
+          @controller.process(@request, @response)
+          decode_rpc_response
+        end
+
+        # ---------------------- internal ---------------------------
+
+        def prepare_request(action, service_name, api_method_name, *args)
+          @request.request_parameters['action'] = action
+          @request.env['REQUEST_METHOD'] = 'POST'
+          @request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
+          @request.env['RAW_POST_DATA'] = encode_rpc_call(service_name, api_method_name, *args)
+          case protocol
+          when :soap
+            soap_action = "/#{@controller.controller_name}/#{service_name}/#{public_method_name(service_name, api_method_name)}" 
+            @request.env['HTTP_SOAPACTION'] = soap_action
+          when :xmlrpc
+            @request.env.delete('HTTP_SOAPACTION')
+          end
+        end
+
+        def encode_rpc_call(service_name, api_method_name, *args)
+          case @controller.web_service_dispatching_mode
+          when :direct
+            api = @controller.class.web_service_api
+          when :delegated, :layered
+            api = @controller.web_service_object(service_name.to_sym).class.web_service_api
+          end
+          info = api.api_methods[api_method_name.to_sym]
+          ((info[:expects] || []) + (info[:returns] || [])).each do |spec|
+            marshaler.register_type spec
+          end
+          expects = info[:expects]
+          args = args.dup
+          (0..(args.length-1)).each do |i|
+            type_binding = marshaler.register_type(expects ? expects[i] : args[i].class)
+            info = WS::ParamInfo.create(expects ? expects[i] : args[i].class, type_binding, i)
+            args[i] = marshaler.marshal(WS::Param.new(args[i], info))
+          end
+          encoder.encode_rpc_call(public_method_name(service_name, api_method_name), args)
+        end
+
+        def decode_rpc_response
+          public_method_name, return_value = encoder.decode_rpc_response(@response.body)
+          result = marshaler.unmarshal(return_value).value
+          unless @return_exceptions
+            exception = is_exception?(result)
+            raise exception if exception
+          end
+          result
+        end
+
+        def public_method_name(service_name, api_method_name)
+          public_name = service_api(service_name).public_api_method_name(api_method_name)
+          if @controller.web_service_dispatching_mode == :layered
+            '%s.%s' % [service_name.to_s, public_name]
+          else
+            public_name
+          end
+        end
+
+        def service_api(service_name)
+          case @controller.web_service_dispatching_mode
+          when :direct
+            @controller.class.web_service_api
+          when :delegated, :layered
+            @controller.web_service_object(service_name.to_sym).class.web_service_api
+          end
+        end
+
+        def protocol
+          @protocol ||= :soap
+        end
+
+        def marshaler
+          case protocol
+          when :soap
+            @soap_marshaler ||= WS::Marshaling::SoapMarshaler.new 'urn:ActionWebService'
+          when :xmlrpc
+            @xmlrpc_marshaler ||= WS::Marshaling::XmlRpcMarshaler.new
+          end
+        end
+
+        def encoder
+          case protocol
+          when :soap
+            @soap_encoder ||= WS::Encoding::SoapRpcEncoding.new 'urn:ActionWebService'
+          when :xmlrpc
+            @xmlrpc_encoder ||= WS::Encoding::XmlRpcEncoding.new
+          end
+        end
+
+        def is_exception?(obj)
+          case protocol
+          when :soap
+            (obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && \
+            obj.detail.cause.is_a?(Exception)) ? obj.detail.cause : nil
+          when :xmlrpc
+            obj.is_a?(XMLRPC::FaultException) ? obj : nil
+          end
+        end
+    end
+  end
+end

data/lib/action_web_service/vendor/ws.rb

@@ -0,0 +1,4 @@
+require 'ws/common'
+require 'ws/types'
+require 'ws/marshaling'
+require 'ws/encoding'

data/lib/action_web_service/vendor/ws/common.rb

@@ -0,0 +1,8 @@
+module WS
+  class WSError < StandardError
+  end
+
+  def self.derived_from?(ancestor, child)
+    child.ancestors.include?(ancestor)
+  end
+end

data/lib/action_web_service/vendor/ws/encoding.rb

@@ -0,0 +1,3 @@
+require 'ws/encoding/abstract'
+require 'ws/encoding/soap_rpc_encoding'
+require 'ws/encoding/xmlrpc_encoding'

data/lib/action_web_service/vendor/ws/encoding/abstract.rb

@@ -0,0 +1,26 @@
+module WS
+  module Encoding
+    # Encoders operate on _foreign_ objects. That is, Ruby object
+    # instances that are the _marshaling format specific_ representation
+    # of objects. In other words, objects that have not yet been marshaled, but
+    # are in protocol-specific form (such as an AST or DOM element), and not
+    # native Ruby form.
+    class AbstractEncoding
+      def encode_rpc_call(method_name, params)
+        raise NotImplementedError
+      end
+
+      def decode_rpc_call(obj)
+        raise NotImplementedError
+      end
+
+      def encode_rpc_response(method_name, return_value)
+        raise NotImplementedError
+      end
+
+      def decode_rpc_response(obj)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/action_web_service/vendor/ws/encoding/soap_rpc_encoding.rb

@@ -0,0 +1,90 @@
+require 'soap/processor'
+require 'soap/mapping'
+require 'soap/rpc/element'
+
+module WS
+  module Encoding
+    class SoapRpcError < WSError
+    end
+
+    class SoapRpcEncoding < AbstractEncoding
+      attr_accessor :method_namespace
+
+      def initialize(method_namespace='')
+        @method_namespace = method_namespace
+      end
+
+      def encode_rpc_call(method_name, foreign_params)
+        qname = create_method_qname(method_name)
+        param_def = []
+        params = foreign_params.map do |p|
+          param_def << ['in', p.param.info.name, p.param.info.data.mapping]
+          [p.param.info.name, p.soap_object]
+        end
+        request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
+        request.set_param(params)
+        envelope = create_soap_envelope(request)
+        SOAP::Processor.marshal(envelope)
+      end
+
+      def decode_rpc_call(obj)
+        envelope = SOAP::Processor.unmarshal(obj)
+        unless envelope
+          raise(SoapRpcError, "Malformed SOAP request")
+        end
+        request = envelope.body.request
+        method_name = request.elename.name
+        params = request.collect do |key, value|
+          info = ParamInfo.new(key, nil, nil)
+          param = Param.new(nil, info)
+          Marshaling::SoapForeignObject.new(param, request[key])
+        end
+        [method_name, params]
+      end
+
+      def encode_rpc_response(method_name, return_value)
+        response = nil
+        qname = create_method_qname(method_name)
+        if return_value.nil?
+          response = SOAP::RPC::SOAPMethodResponse.new(qname, nil)
+        else
+          param = return_value.param
+          soap_object = return_value.soap_object
+          param_def = [['retval', 'return', param.info.data.mapping]]
+          if soap_object.is_a?(SOAP::SOAPFault)
+            response = soap_object
+          else
+            response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
+            response.retval = soap_object
+          end
+        end
+        envelope = create_soap_envelope(response)
+        SOAP::Processor.marshal(envelope)
+      end
+
+      def decode_rpc_response(obj)
+        envelope = SOAP::Processor.unmarshal(obj)
+        unless envelope
+          raise(SoapRpcError, "Malformed SOAP response")
+        end
+        method_name = envelope.body.request.elename.name
+        return_value = envelope.body.response
+        info = ParamInfo.new('return', nil, nil)
+        param = Param.new(nil, info)
+        return_value = Marshaling::SoapForeignObject.new(param, return_value)
+        [method_name, return_value]
+      end
+
+      private
+        def create_soap_envelope(body)
+          header = SOAP::SOAPHeader.new
+          body = SOAP::SOAPBody.new(body)
+          SOAP::SOAPEnvelope.new(header, body)
+        end
+
+        def create_method_qname(method_name)
+          XSD::QName.new(@method_namespace, method_name)
+        end
+    end
+  end
+end