refactoring:

  * move dispatching out of the Container into Dispatcher, it makes more sense
    for Container to only contain the list of web services defined
    in it.

  * collapse Wsdl and ActionController "routers" into
    an ActionController-specific module, no advantage
    to having them seperate as they were quite tightly
    coupled. rename to Dispatcher, to avoi
    confusion with Routing.

  * add a "_thing" suffix to concept-specific filenames. this is so that
    we don't end up with many soap.rb files, for example.

  * remove "virtual invocation" support. adds complexity, and it doesn't
    seem to add any value.


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

1 files changed, 0 insertions, 147 deletions

diff --git a/actionwebservice/lib/action_web_service/container.rb b/actionwebservice/lib/action_web_service/container.rb
index 6fa14def56..f02717579e 100644
--- a/actionwebservice/lib/action_web_service/container.rb
+++ b/actionwebservice/lib/action_web_service/container.rb
@@ -5,8 +5,6 @@ module ActionWebService # :nodoc:
 
     def self.append_features(base) # :nodoc:
       super
-      base.class_inheritable_option(:web_service_dispatching_mode, :direct)
-      base.class_inheritable_option(:web_service_exception_reporting, true)
       base.extend(ClassMethods)
       base.send(:include, ActionWebService::Container::InstanceMethods)
     end
@@ -82,151 +80,6 @@ module ActionWebService # :nodoc:
         service = info[:block]
         service ? instance_eval(&service) : info[:object]
       end
-
-      private
-        def dispatch_web_service_request(protocol_request)
-          case web_service_dispatching_mode
-          when :direct
-            dispatch_direct_web_service_request(protocol_request)
-          when :delegated
-            dispatch_delegated_web_service_request(protocol_request)
-          else
-            raise(ContainerError, "unsupported dispatching mode :#{web_service_dispatching_mode}")
-          end
-        end
-
-        def dispatch_direct_web_service_request(protocol_request)
-          public_method_name = protocol_request.public_method_name
-          api = self.class.web_service_api
-          method_name = api.api_method_name(public_method_name)
-          block = nil
-          expects = nil
-          if method_name
-            signature = api.api_methods[method_name]
-            expects = signature[:expects]
-            protocol_request.type = Protocol::CheckedMessage
-            protocol_request.signature = expects
-            protocol_request.return_signature = signature[:returns]
-          else
-            protocol_request.type = Protocol::UncheckedMessage
-            system_methods = self.class.read_inheritable_attribute('default_system_methods') || {}
-            protocol = protocol_request.protocol
-            block = system_methods[protocol.class]
-            unless block
-              method_name = api.default_api_method
-              unless method_name && respond_to?(method_name)
-                raise(ContainerError, "no such method ##{public_method_name}")
-              end
-            end
-          end
-
-          @method_params = protocol_request.unmarshal
-          @params ||= {}
-          if expects
-            (1..@method_params.size).each do |i|
-              i -= 1
-              if expects[i].is_a?(Hash)
-                @params[expects[i].keys.shift.to_s] = @method_params[i]
-              else
-                @params["param#{i}"] = @method_params[i]
-              end
-            end
-          end
-
-          if respond_to?(:before_action)
-            @params['action'] = method_name.to_s
-            return protocol_request.marshal(nil) if before_action == false
-          end
-
-          perform_invoke = lambda do
-            if block
-              block.call(public_method_name, self.class, *@method_params)
-            else
-              send(method_name)
-            end
-          end
-          try_default = true
-          result = nil
-          catch(:try_default) do
-            result = perform_invoke.call
-            try_default = false
-          end
-          if try_default
-            method_name = api.default_api_method
-            if method_name
-              protocol_request.type = Protocol::UncheckedMessage
-            else
-              raise(ContainerError, "no such method ##{public_method_name}")
-            end
-            result = perform_invoke.call
-          end
-          after_action if respond_to?(:after_action)
-          protocol_request.marshal(result)
-        end
-
-        def dispatch_delegated_web_service_request(protocol_request)
-          web_service_name = protocol_request.web_service_name
-          service = web_service_object(web_service_name)
-          api = service.class.web_service_api
-          public_method_name = protocol_request.public_method_name
-          method_name = api.api_method_name(public_method_name)
-
-          invocation = ActionWebService::Invocation::InvocationRequest.new(
-            ActionWebService::Invocation::ConcreteInvocation,
-            public_method_name,
-            method_name)
-
-          if method_name
-            protocol_request.type = Protocol::CheckedMessage
-            signature = api.api_methods[method_name]
-            protocol_request.signature = signature[:expects]
-            protocol_request.return_signature = signature[:returns]
-            invocation.params = protocol_request.unmarshal
-          else
-            protocol_request.type = Protocol::UncheckedMessage
-            invocation.type = ActionWebService::Invocation::VirtualInvocation
-            system_methods = self.class.read_inheritable_attribute('default_system_methods') || {}
-            protocol = protocol_request.protocol
-            block = system_methods[protocol.class]
-            if block
-              invocation.block = block
-              invocation.block_params << service.class
-            else
-              method_name = api.default_api_method
-              if method_name && service.respond_to?(method_name)
-                invocation.params = protocol_request.unmarshal
-                invocation.method_name = method_name.to_sym
-              else
-                raise(ContainerError, "no such method /#{web_service_name}##{public_method_name}")
-              end
-            end
-          end
-
-          canceled_reason = nil
-          canceled_block = lambda{|r| canceled_reason = r}
-          perform_invoke = lambda do
-            service.perform_invocation(invocation, &canceled_block)
-          end
-          try_default = true
-          result = nil
-          catch(:try_default) do
-            result = perform_invoke.call
-            try_default = false
-          end
-          if try_default
-            method_name = api.default_api_method
-            if method_name
-              protocol_request.type = Protocol::UncheckedMessage
-              invocation.params = protocol_request.unmarshal
-              invocation.method_name = method_name.to_sym
-              invocation.type = ActionWebService::Invocation::UnpublishedConcreteInvocation
-            else
-              raise(ContainerError, "no such method /#{web_service_name}##{public_method_name}")
-            end
-            result = perform_invoke.call
-          end
-          protocol_request.marshal(result)
-        end
     end
   end
 end