actionwebservice 0.5.0 → 0.6.0

data/lib/action_web_service/client/xmlrpc_client.rb

@@ -31,6 +31,7 @@ module ActionWebService # :nodoc:
         @api = api
         @handler_name = options[:handler_name]
         @client = XMLRPC::Client.new2(endpoint_uri, options[:proxy], options[:timeout])
+        @marshaler = WS::Marshaling::XmlRpcMarshaler.new
       end
 
       protected
@@ -43,18 +44,21 @@ module ActionWebService # :nodoc:
 
         def transform_outgoing_method_params(method_name, params)
           info = @api.api_methods[method_name.to_sym]
-          signature = info[:expects]
-          signature_length = signature.nil?? 0 : signature.length
-          if signature_length != params.length
-            raise(ProtocolError, "API declares #{public_name(method_name)} to accept " +
-                                 "#{signature_length} parameters, but #{params.length} parameters " + 
-                                 "were supplied")
+          expects = info[:expects]
+          expects_length = expects.nil?? 0 : expects.length
+          if expects_length != params.length
+            raise(ClientError, "API declares #{public_name(method_name)} to accept " +
+                               "#{expects_length} parameters, but #{params.length} parameters " + 
+                               "were supplied")
           end
-          if signature_length > 0
-            signature = Protocol::XmlRpc::XmlRpcProtocol.transform_array_types(signature)
-            (1..signature.size).each do |i|
-              i -= 1
-              params[i] = Protocol::XmlRpc::XmlRpcProtocol.ruby_to_xmlrpc(params[i], lookup_class(signature[i]))
+          params = params.dup
+          if expects_length > 0
+            i = 0
+            expects.each do |spec|
+              type_binding = @marshaler.register_type(spec)
+              info = WS::ParamInfo.create(spec, type_binding, i)
+              params[i] = @marshaler.marshal(WS::Param.new(params[i], info))
+              i += 1
             end
           end
           params
@@ -62,10 +66,11 @@ module ActionWebService # :nodoc:
 
         def transform_return_value(method_name, return_value)
           info = @api.api_methods[method_name.to_sym]
-          return true unless signature = info[:returns]
-          param_klass = lookup_class(signature[0])
-          signature = Protocol::XmlRpc::XmlRpcProtocol.transform_array_types([param_klass])
-          Protocol::XmlRpc::XmlRpcProtocol.xmlrpc_to_ruby(return_value, signature[0])
+          return true unless returns = info[:returns]
+          type_binding = @marshaler.register_type(returns[0])
+          info = WS::ParamInfo.create(returns[0], type_binding, 0)
+          info.name = 'return'
+          @marshaler.transform_inbound(WS::Param.new(return_value, info))
         end
 
         def public_name(method_name)

data/lib/action_web_service/container.rb

@@ -1,85 +1,3 @@
-module ActionWebService # :nodoc:
-  module Container # :nodoc:
-    class ContainerError < ActionWebService::ActionWebServiceError # :nodoc:
-    end
-
-    def self.append_features(base) # :nodoc:
-      super
-      base.extend(ClassMethods)
-      base.send(:include, ActionWebService::Container::InstanceMethods)
-    end
-
-    module ClassMethods
-      # Declares a web service that will provides access to the API of the given
-      # +object+. +object+ must be an ActionWebService::Base derivative.
-      #
-      # Web service object creation can either be _immediate_, where the object
-      # instance is given at class definition time, or _deferred_, where
-      # object instantiation is delayed until request time.
-      #
-      # ==== Immediate web service object example
-      #
-      #   class ApiController < ApplicationController
-      #     web_service_dispatching_mode :delegated
-      #
-      #     web_service :person, PersonService.new
-      #   end
-      #
-      # For deferred instantiation, a block should be given instead of an
-      # object instance. This block will be executed in controller instance
-      # context, so it can rely on controller instance variables being present.
-      #
-      # ==== Deferred web service object example
-      #
-      #   class ApiController < ApplicationController
-      #     web_service_dispatching_mode :delegated
-      #
-      #     web_service(:person) { PersonService.new(@request.env) }
-      #   end
-      def web_service(name, object=nil, &block)
-        if (object && block_given?) || (object.nil? && block.nil?)
-          raise(ContainerError, "either service, or a block must be given")
-        end
-        name = name.to_sym
-        if block_given?
-          info = { name => { :block => block } }
-        else
-          info = { name => { :object => object } }
-        end
-        write_inheritable_hash("web_services", info)
-        call_web_service_definition_callbacks(self, name, info)
-      end
-
-      # Whether this service contains a service with the given +name+
-      def has_web_service?(name)
-        web_services.has_key?(name.to_sym)
-      end
-
-      def web_services # :nodoc:
-        read_inheritable_attribute("web_services") || {}
-      end
-
-      def add_web_service_definition_callback(&block) # :nodoc:
-        write_inheritable_array("web_service_definition_callbacks", [block])
-      end
-
-      private
-        def call_web_service_definition_callbacks(container_class, web_service_name, service_info)
-          (read_inheritable_attribute("web_service_definition_callbacks") || []).each do |block|
-            block.call(container_class, web_service_name, service_info)
-          end
-        end
-    end
-
-    module InstanceMethods # :nodoc:
-      def web_service_object(web_service_name)
-        info = self.class.web_services[web_service_name.to_sym]
-        unless info
-          raise(ContainerError, "no such web service '#{web_service_name}'")
-        end
-        service = info[:block]
-        service ? instance_eval(&service) : info[:object]
-      end
-    end
-  end
-end
+require 'action_web_service/container/direct_container'
+require 'action_web_service/container/delegated_container'
+require 'action_web_service/container/action_controller_container'

data/lib/action_web_service/{api/action_controller.rb → container/action_controller_container.rb}

@@ -1,5 +1,5 @@
 module ActionWebService # :nodoc:
-  module API # :nodoc:
+  module Container # :nodoc:
     module ActionController # :nodoc:
       def self.append_features(base) # :nodoc:
         base.class_eval do 
@@ -36,7 +36,7 @@ module ActionWebService # :nodoc:
             api_klass = options.delete(:api) || require_web_service_api(name)
             class_eval do
               define_method(name) do
-                probe_protocol_client(api_klass, protocol, endpoint_uri, options)
+                create_web_service_client(api_klass, protocol, endpoint_uri, options)
               end
               protected name
             end

data/lib/action_web_service/container/delegated_container.rb

@@ -0,0 +1,87 @@
+module ActionWebService # :nodoc:
+  module Container # :nodoc:
+    module Delegated # :nodoc:
+      class ContainerError < ActionWebServiceError # :nodoc:
+      end
+  
+      def self.append_features(base) # :nodoc:
+        super
+        base.extend(ClassMethods)
+        base.send(:include, ActionWebService::Container::Delegated::InstanceMethods)
+      end
+  
+      module ClassMethods
+        # Declares a web service that will provides access to the API of the given
+        # +object+. +object+ must be an ActionWebService::Base derivative.
+        #
+        # Web service object creation can either be _immediate_, where the object
+        # instance is given at class definition time, or _deferred_, where
+        # object instantiation is delayed until request time.
+        #
+        # ==== Immediate web service object example
+        #
+        #   class ApiController < ApplicationController
+        #     web_service_dispatching_mode :delegated
+        #
+        #     web_service :person, PersonService.new
+        #   end
+        #
+        # For deferred instantiation, a block should be given instead of an
+        # object instance. This block will be executed in controller instance
+        # context, so it can rely on controller instance variables being present.
+        #
+        # ==== Deferred web service object example
+        #
+        #   class ApiController < ApplicationController
+        #     web_service_dispatching_mode :delegated
+        #
+        #     web_service(:person) { PersonService.new(@request.env) }
+        #   end
+        def web_service(name, object=nil, &block)
+          if (object && block_given?) || (object.nil? && block.nil?)
+            raise(ContainerError, "either service, or a block must be given")
+          end
+          name = name.to_sym
+          if block_given?
+            info = { name => { :block => block } }
+          else
+            info = { name => { :object => object } }
+          end
+          write_inheritable_hash("web_services", info)
+          call_web_service_definition_callbacks(self, name, info)
+        end
+  
+        # Whether this service contains a service with the given +name+
+        def has_web_service?(name)
+          web_services.has_key?(name.to_sym)
+        end
+  
+        def web_services # :nodoc:
+          read_inheritable_attribute("web_services") || {}
+        end
+  
+        def add_web_service_definition_callback(&block) # :nodoc:
+          write_inheritable_array("web_service_definition_callbacks", [block])
+        end
+  
+        private
+          def call_web_service_definition_callbacks(container_class, web_service_name, service_info)
+            (read_inheritable_attribute("web_service_definition_callbacks") || []).each do |block|
+              block.call(container_class, web_service_name, service_info)
+            end
+          end
+      end
+  
+      module InstanceMethods # :nodoc:
+        def web_service_object(web_service_name)
+          info = self.class.web_services[web_service_name.to_sym]
+          unless info
+            raise(ContainerError, "no such web service '#{web_service_name}'")
+          end
+          service = info[:block]
+          service ? instance_eval(&service) : info[:object]
+        end
+      end
+    end
+  end
+end

data/lib/action_web_service/container/direct_container.rb

@@ -0,0 +1,70 @@
+module ActionWebService # :nodoc:
+  module Container # :nodoc:
+    module Direct # :nodoc:
+      class ContainerError < ActionWebServiceError # :nodoc:
+      end
+
+      def self.append_features(base) # :nodoc:
+        super
+        base.extend(ClassMethods)
+      end
+  
+      module ClassMethods
+        # Attaches ActionWebService API +definition+ to the calling class.
+        #
+        # Action Controllers can have a default associated API, removing the need
+        # to call this method if you follow the Action Web Service naming conventions.
+        #
+        # A controller with a class name of GoogleSearchController will
+        # implicitly load <tt>app/apis/google_search_api.rb</tt>, and expect the
+        # API definition class to be named <tt>GoogleSearchAPI</tt> or
+        # <tt>GoogleSearchApi</tt>.
+        #
+        # ==== Service class example
+        #
+        #   class MyService < ActionWebService::Base
+        #     web_service_api MyAPI
+        #   end
+        #
+        #   class MyAPI < ActionWebService::API::Base
+        #     ...
+        #   end
+        #
+        # ==== Controller class example
+        #
+        #   class MyController < ActionController::Base
+        #     web_service_api MyAPI
+        #   end
+        #
+        #   class MyAPI < ActionWebService::API::Base
+        #     ...
+        #   end
+        def web_service_api(definition=nil)
+          if definition.nil?
+            read_inheritable_attribute("web_service_api")
+          else
+            if definition.is_a?(Symbol)
+              raise(ContainerError, "symbols can only be used for #web_service_api inside of a controller")
+            end
+            unless definition.respond_to?(:ancestors) && definition.ancestors.include?(ActionWebService::API::Base)
+              raise(ContainerError, "#{definition.to_s} is not a valid API definition")
+            end
+            write_inheritable_attribute("web_service_api", definition)
+            call_web_service_api_callbacks(self, definition)
+          end
+        end
+  
+        def add_web_service_api_callback(&block) # :nodoc:
+          write_inheritable_array("web_service_api_callbacks", [block])
+        end
+  
+        private
+          def call_web_service_api_callbacks(container_class, definition)
+            (read_inheritable_attribute("web_service_api_callbacks") || []).each do |block|
+              block.call(container_class, definition)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/action_web_service/dispatcher/abstract.rb

@@ -12,138 +12,136 @@ module ActionWebService # :nodoc:
       base.send(:include, ActionWebService::Dispatcher::InstanceMethods)
     end
 
+    def self.layered_service_name(public_method_name) # :nodoc:
+      if public_method_name =~ /^([^\.]+)\.(.*)$/
+        $1
+      else
+        nil
+      end
+    end
+
     module InstanceMethods # :nodoc:
       private
-        def dispatch_web_service_request(action_pack_request)
-          protocol_request = protocol_response = nil
-          bm = Benchmark.measure do
-            protocol_request = probe_request_protocol(action_pack_request)
-            protocol_response = dispatch_protocol_request(protocol_request)
+        def invoke_web_service_request(protocol_request)
+          invocation = web_service_invocation(protocol_request)
+          case web_service_dispatching_mode
+          when :direct
+            web_service_direct_invoke(invocation)
+          when :delegated, :layered
+            web_service_delegated_invoke(invocation)
           end
-          [protocol_request, protocol_response, bm.real, nil]
-        rescue Exception => e
-          protocol_response = prepare_exception_response(protocol_request, e) 
-          [protocol_request, prepare_exception_response(protocol_request, e), nil, e]
         end
       
-        def dispatch_protocol_request(protocol_request)
-          case web_service_dispatching_mode
-          when :direct
-            dispatch_direct_request(protocol_request)
-          when :delegated
-            dispatch_delegated_request(protocol_request)
+        def web_service_direct_invoke(invocation)
+          @method_params = invocation.method_ordered_params
+          return_value = self.__send__(invocation.api_method_name)
+          if invocation.api.has_api_method?(invocation.api_method_name)
+            returns = invocation.returns ? invocation.returns[0] : nil
           else
-            raise(ContainerError, "unsupported dispatching mode :#{web_service_dispatching_mode}")
+            returns = return_value.class
           end
+          invocation.protocol.marshal_response(invocation.public_method_name, return_value, returns)
         end
 
-        def dispatch_direct_request(protocol_request)
-          request = prepare_dispatch_request(protocol_request)
-          return_value = direct_invoke(request)
-          protocol_request.marshal(return_value)
-        end
-
-        def dispatch_delegated_request(protocol_request)
-          request = prepare_dispatch_request(protocol_request)
-          return_value = delegated_invoke(request)
-          protocol_request.marshal(return_value)
-        end
-
-        def direct_invoke(request)
-          return nil unless before_direct_invoke(request)
-          return_value = send(request.method_name)
-          after_direct_invoke(request)
-          return_value
-        end
-
-        def before_direct_invoke(request)
-          @method_params = request.params
-        end
-
-        def after_direct_invoke(request)
-        end
-
-        def delegated_invoke(request)
+        def web_service_delegated_invoke(invocation)
           cancellation_reason = nil
-          web_service = request.web_service
-          return_value = web_service.perform_invocation(request.method_name, request.params) do |x|
+          return_value = invocation.service.perform_invocation(invocation.api_method_name, invocation.method_ordered_params) do |x|
             cancellation_reason = x
           end
           if cancellation_reason
             raise(DispatcherError, "request canceled: #{cancellation_reason}")
           end
-          return_value
+          returns = invocation.returns ? invocation.returns[0] : nil
+          invocation.protocol.marshal_response(invocation.public_method_name, return_value, returns)
         end
 
-        def prepare_dispatch_request(protocol_request)
-          api = method_name = web_service_name = web_service = params = nil
-          public_method_name = protocol_request.public_method_name
+        def web_service_invocation(request)
+          public_method_name = request.method_name
+          invocation = Invocation.new
+          invocation.protocol = request.protocol
+          invocation.service_name = request.service_name
+          if web_service_dispatching_mode == :layered
+            if request.method_name =~ /^([^\.]+)\.(.*)$/
+              public_method_name = $2
+              invocation.service_name = $1
+            end
+          end
+          invocation.public_method_name = public_method_name
           case web_service_dispatching_mode
           when :direct
-            api = self.class.web_service_api
-          when :delegated
-            web_service_name = protocol_request.web_service_name
-            web_service = web_service_object(web_service_name)
-            api = web_service.class.web_service_api
+            invocation.api = self.class.web_service_api
+            invocation.service = self
+          when :delegated, :layered
+            invocation.service = web_service_object(invocation.service_name) rescue nil
+            unless invocation.service
+              raise(DispatcherError, "service #{invocation.service_name} not available")
+            end
+            invocation.api = invocation.service.class.web_service_api
           end
-          method_name  = api.api_method_name(public_method_name)
-          signature = nil
-          if method_name
-            signature = api.api_methods[method_name]
-            protocol_request.type = Protocol::CheckedMessage
-            protocol_request.signature = signature[:expects]
-            protocol_request.return_signature = signature[:returns]
+          if invocation.api.has_public_api_method?(public_method_name)
+            invocation.api_method_name = invocation.api.api_method_name(public_method_name)
           else
-            method_name = api.default_api_method
-            if method_name
-              protocol_request.type = Protocol::UncheckedMessage
+            if invocation.api.default_api_method.nil?
+              raise(DispatcherError, "no such method '#{public_method_name}' on API #{invocation.api}")
             else
-              raise(DispatcherError, "no such method #{web_service_name}##{public_method_name}")
+              invocation.api_method_name = invocation.api.default_api_method.to_s.to_sym
             end
           end
-          params = protocol_request.unmarshal
-          DispatchRequest.new(
-            :api                => api,
-            :public_method_name => public_method_name,
-            :method_name        => method_name,
-            :signature          => signature,
-            :web_service_name   => web_service_name,
-            :web_service        => web_service,
-            :params             => params)
-        end
-
-        def prepare_exception_response(protocol_request, exception)
-          if protocol_request && exception
-            case web_service_dispatching_mode
-            when :direct
-              if web_service_exception_reporting
-                return protocol_request.protocol.marshal_exception(exception)
-              end
-            when :delegated
-              web_service = web_service_object(protocol_request.web_service_name)
-              if web_service && web_service.class.web_service_exception_reporting
-                return protocol_request.protocol.marshal_exception(exception)
+          unless invocation.service.respond_to?(invocation.api_method_name)
+              raise(DispatcherError, "no such method '#{public_method_name}' on API #{invocation.api} (#{invocation.api_method_name})")
+          end
+          info = invocation.api.api_methods[invocation.api_method_name]
+          invocation.expects = info ? info[:expects] : nil
+          invocation.returns = info ? info[:returns] : nil
+          if invocation.expects
+            i = 0
+            invocation.method_ordered_params = request.method_params.map do |param|
+              if invocation.protocol.is_a?(Protocol::XmlRpc::XmlRpcProtocol)
+                marshaler = invocation.protocol.marshaler
+                decoded_param = WS::Encoding::XmlRpcDecodedParam.new(param.info.name, param.value)
+                marshaled_param = marshaler.typed_unmarshal(decoded_param, invocation.expects[i]) rescue nil
+                param = marshaled_param ? marshaled_param : param
               end
+              i += 1
+              param.value
+            end
+            i = 0
+            params = []
+            invocation.expects.each do |spec|
+              type_binding = invocation.protocol.register_signature_type(spec)
+              info = WS::ParamInfo.create(spec, type_binding, i)
+              params << WS::Param.new(invocation.method_ordered_params[i], info)
+              i += 1
+            end
+            invocation.method_ws_params = params
+            invocation.method_named_params = {}
+            invocation.method_ws_params.each do |param|
+              invocation.method_named_params[param.info.name] = param.value
             end
           else
-            protocol_request.protocol.marshal_exception(RuntimeError.new("missing protocol request or exception"))
+            invocation.method_ordered_params = []
+            invocation.method_named_params = {}
           end
-        rescue Exception
-          nil
+          if invocation.returns
+            invocation.returns.each do |spec|
+              invocation.protocol.register_signature_type(spec)
+            end
+          end
+          invocation
         end
 
-        class DispatchRequest
-          attr :api
-          attr :public_method_name
-          attr :method_name
-          attr :signature
-          attr :web_service_name
-          attr :web_service
-          attr :params
-
-          def initialize(values={})
-            values.each{|k,v| instance_variable_set("@#{k.to_s}", v)}
-          end
+        class Invocation # :nodoc:
+          attr_accessor :protocol
+          attr_accessor :service_name
+          attr_accessor :api
+          attr_accessor :public_method_name
+          attr_accessor :api_method_name
+          attr_accessor :method_ordered_params
+          attr_accessor :method_named_params
+          attr_accessor :method_ws_params
+          attr_accessor :expects
+          attr_accessor :returns
+          attr_accessor :service
         end
     end
   end