actionservice 0.2.100 → 0.2.102

data/lib/action_service/protocol/abstract.rb

@@ -1,22 +1,23 @@
 module ActionService
   module Protocol
+    CheckedMessage = :checked
+    UncheckedMessage = :unchecked
+
     class ProtocolError < ActionService::ActionServiceError
     end
-    class SystemExportNotHandledError < ProtocolError
-    end
 
     class AbstractProtocol
-      attr :container_klass
+      attr :container_class
 
-      def initialize(container_klass)
-        @container_klass = container_klass
+      def initialize(container_class)
+        @container_class = container_class
       end
 
-      def unmarshal_request(request_info, export_info, strict=true)
+      def unmarshal_request(protocol_request)
         raise NotImplementedError
       end
 
-      def marshal_response(request_info, export_info, return_value, strict=true)
+      def marshal_response(protocol_request, return_value)
         raise NotImplementedError
       end
 
@@ -24,71 +25,100 @@ module ActionService
         raise NotImplementedError
       end
 
-      def request_info
-        raise NotImplementedError
+      def self.create_protocol_request(container_class, action_pack_request)
+        nil
       end
+    end
 
-      def request_supported?(request)
-        raise NotImplementedError
+    class AbstractProtocolMessage
+      attr_accessor :signature
+      attr_accessor :return_signature
+      attr_accessor :type
+
+      def initialize(options={})
+        @signature = @return_signature = nil
+        @type = options[:type] || CheckedMessage
       end
-      
-      private
-        def validate_types(method_name, signature, params, kind)
-          unless signature.length == params.length
-            raise(ProtocolError, "signature/parameter mismatch")
-          end
-          case kind
-          when :in
-            extra_msg = ' (Input parameter %d of method "%s")'
-          when :out
-            extra_msg = ' (Return value %d of method "%s")'
-          end
-          i = 0
-          signature.each do |klass|
-            check_compatibility(params[i].class, klass, extra_msg % [i+1, method_name])
-            i += 1
+
+      def signature=(value)
+        return if value.nil?
+        @signature = []
+        value.each do |klass|
+          if klass.is_a?(Hash)
+            @signature << klass.values.shift
+          else
+            @signature << klass
           end
         end
+        @signature
+      end
 
-        def check_compatibility(given_klass, signature_klass, extra_msg=nil)
-          if (given_klass == TrueClass or given_klass == FalseClass) and \
-             (signature_klass == TrueClass or signature_klass == FalseClass)
-            return true
-          end
-          unless given_klass.ancestors.include?(signature_klass) || \
-                 signature_klass.ancestors.include?(given_klass)
-            raise(ProtocolError, "value of type #{given_klass.name} is not compatible " +
-                                 "with expected type #{signature_klass.name}" +
-                                 (extra_msg ? extra_msg : ''))
-          end
+      def checked?
+        @type == CheckedMessage
+      end
+
+      def check_parameter_types(values, signature)
+        return unless checked? && signature
+        unless signature.length == values.length
+          raise(ProtocolError, "Signature and parameter lengths mismatch")
         end
+        (1..signature.length).each do |i|
+          check_compatibility(signature[i-1], values[i-1].class)
+        end
+      end
+
+      def check_compatibility(expected_class, received_class)
+        return if \
+            (expected_class == TrueClass or expected_class == FalseClass) and \
+            (received_class == TrueClass or received_class == FalseClass)
+        unless received_class.ancestors.include?(expected_class) or \
+               expected_class.ancestors.include?(received_class)
+          raise(ProtocolError, "value of type #{received_class.name} is not " +
+                               "compatible with expected type #{expected_class.name}")
+        end
+      end
     end
 
-    class ServiceRequestInfo
-      attr :service_name
-      attr :public_method_name
+    class ProtocolRequest < AbstractProtocolMessage
+      attr :protocol
       attr :raw_body
-      attr :content_type
-      attr :protocol_info
 
-      def initialize(service_name, public_method_name, raw_body, content_type, protocol_info=nil)
+      attr_accessor :service_name
+      attr_accessor :public_method_name
+      attr_accessor :content_type
+      attr_accessor :values
+
+      def initialize(protocol, raw_body, service_name, public_method_name, content_type, options={})
+        super(options)
+        @protocol = protocol
+        @raw_body = raw_body
         @service_name = service_name
         @public_method_name = public_method_name
-        @raw_body = raw_body
         @content_type = content_type
-        @protocol_info = protocol_info
+        @values = nil
+      end
+
+      def unmarshal
+        @values ||= @protocol.unmarshal_request(self)
+      end
+
+      def marshal(return_value)
+        @protocol.marshal_response(self, return_value)
       end
     end
 
-    class ServiceResponseInfo
+    class ProtocolResponse < AbstractProtocolMessage
+      attr :protocol
       attr :raw_body
-      attr :content_type
 
-      def initialize(raw_body, content_type)
+      attr_accessor :content_type
+
+      def initialize(protocol, raw_body, content_type, options={})
+        super(options)
+        @protocol = protocol
         @raw_body = raw_body
         @content_type = content_type
       end
     end
-
   end
 end

data/lib/action_service/protocol/registry.rb

@@ -26,11 +26,9 @@ module ActionService
       module InstanceMethods
         private
           def probe_request_protocol(action_pack_request)
-            (header_and_body_protocols + body_only_protocols).each do |klass|
-              protocol = klass.new(self.class)
-              if protocol.request_supported?(action_pack_request)
-                return protocol
-              end
+            (header_and_body_protocols + body_only_protocols).each do |protocol|
+              protocol_request = protocol.create_protocol_request(self.class, action_pack_request)
+              return protocol_request if protocol_request
             end
             raise(ProtocolError, "unsupported request message format")
           end

data/lib/action_service/protocol/soap.rb

@@ -3,6 +3,7 @@ require 'soap/mapping'
 require 'soap/rpc/element'
 require 'xsd/datatypes'
 require 'xsd/ns'
+require 'singleton'
 
 module ActionService
   module Protocol
@@ -28,78 +29,91 @@ module ActionService
       end
 
       class SoapProtocol < AbstractProtocol
-        def unmarshal_request(request_info, export_info, strict=true)
-          expects = export_info[:expects]
-          unmarshal_soap_message = lambda do
-            envelope = SOAP::Processor.unmarshal(request_info.raw_body)
+        def self.create_protocol_request(container_class, action_pack_request)
+          soap_action = extract_soap_action(action_pack_request)
+          return nil unless soap_action
+          service_name = action_pack_request.parameters['action']
+          public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
+          content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
+          content_type ||= 'text/xml'
+          protocol = SoapProtocol.new(container_class)
+          ProtocolRequest.new(protocol,
+                              action_pack_request.raw_post,
+                              service_name.to_sym,
+                              public_method_name,
+                              content_type)
+        end
+
+        def unmarshal_request(protocol_request)
+          unmarshal = lambda do
+            envelope = SOAP::Processor.unmarshal(protocol_request.raw_body)
             request = envelope.body.request
-            params = request.collect{|k, v| request[k]}
-            soap_to_ruby_array(params)
-          end if expects || !strict
-          if expects
-            map_types(expects)
-            params = unmarshal_soap_message.call
-            validate_types(request_info.public_method_name, expects, params, :in) if expects
-            params
+            values = request.collect{|k, v| request[k]}
+            soap_to_ruby_array(values)
+          end
+          signature = protocol_request.signature
+          if signature
+            map_signature_types(signature)
+            values = unmarshal.call
+            signature = signature.map{|x|mapper.lookup(x).ruby_klass}
+            protocol_request.check_parameter_types(values, signature)
+            values
           else
-            if strict
+            if protocol_request.checked?
               []
             else
-              unmarshal_soap_message.call
+              unmarshal.call
             end
           end
         end
 
-        def marshal_response(request_info, export_info, return_value, strict=true)
-          returns = export_info[:returns]
-          create_param_def = lambda do |ret|
-            map_types(ret)
-            mapping = mapper.lookup(ret[0])
-            ret = [mapping.ruby_klass]
-            retval = fixup_array_types(mapping, return_value)
-            validate_types(request_info.public_method_name, ret, [retval], :out)
-            retval = ruby_to_soap(retval)
+        def marshal_response(protocol_request, return_value)
+          marshal = lambda do |signature|
+            mapping = mapper.lookup(signature[0])
+            return_value = fixup_array_types(mapping, return_value)
+            signature = signature.map{|x|mapper.lookup(x).ruby_klass}
+            protocol_request.check_parameter_types([return_value], signature)
             param_def = [['retval', 'return', mapping.registry_mapping]]
-            [param_def, ret, retval]
-          end if returns || !strict
-          if returns
-            param_def, returns, return_value = create_param_def.call(returns)
+            [param_def, ruby_to_soap(return_value)]
+          end
+          signature = protocol_request.return_signature
+          param_def = nil
+          if signature
+            param_def, return_value = marshal.call(signature)
           else
-            if strict
-              param_def = []
+            if protocol_request.checked?
+              param_def, return_value = nil, nil
             else
-              param_def, returns, return_value = create_param_def.call([return_value.class])
+              param_def, return_value = marshal.call([return_value.class])
             end
           end
-          qname = XSD::QName.new(mapper.custom_namespace, request_info.public_method_name)
+          qname = XSD::QName.new(mapper.custom_namespace,
+                                 protocol_request.public_method_name)
           response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
-          response.retval = return_value if returns
-          ServiceResponseInfo.new(create_response(response), 'text/xml')
-        end
-
-        def marshal_exception(exception)
-          ServiceResponseInfo.new(create_exception_response(exception), 'text/xml')
+          response.retval = return_value unless return_value.nil?
+          ProtocolResponse.new(self, create_response(response), 'text/xml')
         end
 
-        def request_info
-          @request_info
-        end
-
-        def request_supported?(request)
-          soap_action = extract_soap_action(request)
-          return false unless soap_action
-          service_name = request.parameters['action']
-          public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
-          @request_info = ServiceRequestInfo.new(service_name,
-            public_method_name,
-            request.raw_post,
-            request.env['HTTP_CONTENT_TYPE'] || 'text/xml')
-          true
+        def marshal_exception(exc)
+          ProtocolResponse.new(self, create_exception_response(exc), 'text/xml')
         end
 
         private
+          def self.extract_soap_action(request)
+            return nil unless request.method == :post
+            content_type = request.env['HTTP_CONTENT_TYPE'] || 'text/xml'
+            return nil unless content_type
+            soap_action = request.env['HTTP_SOAPACTION']
+            return nil unless soap_action
+            soap_action.gsub!(/^"/, '')
+            soap_action.gsub!(/"$/, '')
+            soap_action.strip!
+            return nil if soap_action.empty?
+            soap_action
+          end
+
           def mapper
-            container_klass.soap_mapper
+            container_class.soap_mapper
           end
 
           def fixup_array_types(mapping, obj)
@@ -113,33 +127,32 @@ module ActionService
             if mapping.is_a?(SoapArrayMapping)
               obj = mapping.ruby_klass.new(obj)
               # man, this is going to be slow for big arrays :(
-              obj.each{|el| fixup_array_types(mapping.element_mapping, el)}
+              (1..obj.size).each do |i|
+                i -= 1
+                obj[i] = fixup_array_types(mapping.element_mapping, obj[i])
+              end
+            else
+              if !mapping.generated_klass.nil? && mapping.generated_klass.respond_to?(:members)
+                # have to map the publically visible structure of the class
+                new_obj = mapping.generated_klass.new
+                mapping.generated_klass.members.each do |name, klass|
+                  new_obj.send("#{name}=", obj.send(name))
+                end
+                obj = new_obj
+              end
             end
             obj
           end
 
-          def extract_soap_action(request)
-            return nil unless request.method == :post
-            content_type = request.env['HTTP_CONTENT_TYPE'] || 'text/xml'
-            return nil unless content_type
-            soap_action = request.env['HTTP_SOAPACTION']
-            return nil unless soap_action
-            soap_action.gsub!(/^"/, '')
-            soap_action.gsub!(/"$/, '')
-            soap_action.strip!
-            return nil if soap_action.empty?
-            soap_action
-          end
-
-          def map_types(types)
+          def map_signature_types(types)
             types.collect{|type| mapper.map(type)}
           end
 
-          def create_response(body, is_error=false)
+          def create_response(body)
             header = SOAP::SOAPHeader.new
             body = SOAP::SOAPBody.new(body)
             envelope = SOAP::SOAPEnvelope.new(header, body)
-            message = SOAP::Processor.marshal(envelope)
+            SOAP::Processor.marshal(envelope)
           end
   
           def create_exception_response(exc)
@@ -149,7 +162,7 @@ module ActionService
               SOAP::SOAPString.new(exc.to_s),
               SOAP::SOAPString.new(self.class.name),
               SOAP::Mapping.obj2soap(detail))
-            create_response(body, true)
+            create_response(body)
           end
 
           def ruby_to_soap(obj)
@@ -175,15 +188,23 @@ module ActionService
           @registry = SOAP::Mapping::Registry.new
           @klass2map = {}
           @custom_types = {}
+          @ar2klass = {}
         end
 
         def lookup(klass)
+          lookup_klass = klass.is_a?(Array) ? klass[0] : klass
+          generated_klass = nil
+          if lookup_klass.ancestors.include?(ActiveRecord::Base)
+            generated_klass = @ar2klass.has_key?(klass) ? @ar2klass[klass] : nil
+            klass = generated_klass if generated_klass
+          end
           return @klass2map[klass] if @klass2map.has_key?(klass)
   
           custom_type = false
   
-          ruby_klass = select_class(klass.is_a?(Array) ? klass[0] : klass)
-          type_name = Inflector.camelize(ruby_klass.name.split(/::/)[-1])
+          ruby_klass = select_class(lookup_klass)
+          generated_klass = @ar2klass[lookup_klass] if @ar2klass.has_key?(lookup_klass)
+          type_name = ruby_klass.name
   
           # Array signatures generate a double-mapping and require generation
           # of an Array subclass to represent the mapping in the SOAP
@@ -230,6 +251,7 @@ module ActionService
             @klass2map[ruby_klass] = SoapMapping.new(self,
                                                      type_name,
                                                      ruby_klass,
+                                                     generated_klass,
                                                      mapping[0],
                                                      mapping,
                                                      custom_type)
@@ -245,6 +267,7 @@ module ActionService
             @klass2map[klass] = SoapMapping.new(self,
                                                 type_name,
                                                 ruby_klass,
+                                                generated_klass,
                                                 mapping[0],
                                                 mapping,
                                                 custom_type)
@@ -256,11 +279,38 @@ module ActionService
         alias :map :lookup
         
         def map_container_services(container, &block)
-          container.class.services.each do |service_name, service_info|
-            object = container.service_object(service_name)
-            service_klass = object.class
+          dispatching_mode = container.service_dispatching_mode
+
+          services = nil
+          case dispatching_mode
+          when :direct
+            service_name = Inflector.underscore(container.class.name.gsub(/Controller$/, ''))
+            services = {
+              service_name => {
+                :info   => nil,
+                :class  => container.class,
+                :object => container,
+              }
+            }
+          when :delegated
+            services = {}
+            container.class.services.each do |service_name, service_info|
+              begin
+                object = container.service_object(service_name)
+              rescue Exception => e
+                raise(ProtocolError, "failed to retrieve service object for mapping: #{e.message}")
+              end
+              services[service_name] = {
+                :info   => service_info,
+                :class  => object.class,
+                :object => object,
+              }
+            end
+          end
+
+          services.each do |service_name, service|
             service_exports = {}
-            object.class.exports.each do |export_name, export_info|
+            service[:class].exports.each do |export_name, export_info|
               expects = export_info[:expects]
               lookup_proc = lambda do |klass|
                 mapping = lookup(klass)
@@ -279,7 +329,17 @@ module ActionService
                 end
                 mapping 
               end
-              expects_signature = expects ? expects.map{|klass| lookup_proc.call(klass)} : nil
+              expects_signature = nil
+              if expects
+                expects_signature = []
+                expects.each do |klass|
+                  if klass.is_a?(Hash)
+                    expects_signature << {klass.keys.shift => lookup_proc.call(klass.values.shift)}
+                  else
+                    expects_signature << lookup_proc.call(klass)
+                  end
+                end
+              end
               returns = export_info[:returns]
               returns_signature = returns ? returns.map{|klass| lookup_proc.call(klass)} : nil
               service_exports[export_name] = {
@@ -287,13 +347,27 @@ module ActionService
                 :returns => returns_signature
               }
             end
-            yield service_name, service_klass, service_exports if block_given?
+            yield service_name, service[:class], service_exports if block_given?
           end
         end
 
         private
           def select_class(klass)
             return Integer if klass == Fixnum
+            if klass.ancestors.include?(ActiveRecord::Base)
+              new_klass = Class.new(ActionService::Struct)
+              new_klass.class_eval <<-EOS
+                def self.name
+                  "#{klass.name}"
+                end
+              EOS
+              klass.columns.each do |column|
+                next if column.klass.nil?
+                new_klass.send(:member, column.name.to_sym, column.klass)
+              end
+              @ar2klass[klass] = new_klass
+              return new_klass
+            end
             klass
           end
 
@@ -311,14 +385,16 @@ module ActionService
 
       class SoapMapping
         attr :ruby_klass
+        attr :generated_klass
         attr :soap_klass
         attr :registry_mapping
   
-        def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping,
+        def initialize(mapper, type_name, ruby_klass, generated_klass, soap_klass, registry_mapping,
                        custom_type=false)
           @mapper = mapper
           @type_name = type_name
           @ruby_klass = ruby_klass
+          @generated_klass = generated_klass
           @soap_klass = soap_klass
           @registry_mapping = registry_mapping
           @custom_type = custom_type
@@ -368,7 +444,7 @@ module ActionService
         attr :element_mapping
   
         def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping, element_mapping)
-          super(mapper, type_name, ruby_klass, soap_klass, registry_mapping, true)
+          super(mapper, type_name, ruby_klass, nil, soap_klass, registry_mapping, true)
           @element_mapping = element_mapping
         end