merged the changes for the upcoming 0.6.0:

seperate out protocol marshaling into a small 'ws' library in vendor, so that
AWS itself only does integration with ActionPack, and so we can keep protocol
specific code in AWS proper to a minimum. refactor unit tests to get 95%
code coverage (for a baseline).

be far more relaxed about the types given to us by the remote side, don't do
any poor man's type checking, just try to cast and marshal to the correct types if
possible, and if not, return what they gave us anyway. this should make interoperating
with fuzzy XML-RPC clients easier.

if exception reporting is turned on, do best-effort error responses, so that
we can avoid "Internal protocol error" with no details if there is a bug in
AWS itself.

also perform extensive cleanups on AWS proper.


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

2 files changed, 7 insertions, 162 deletions

diff --git a/actionwebservice/lib/action_web_service/api/action_controller.rb b/actionwebservice/lib/action_web_service/api/action_controller.rb
deleted file mode 100644
index 604cbfe704..0000000000
--- a/actionwebservice/lib/action_web_service/api/action_controller.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-module ActionWebService # :nodoc:
-  module API # :nodoc:
-    module ActionController # :nodoc:
-      def self.append_features(base) # :nodoc:
-        base.class_eval do 
-          class << self
-            alias_method :inherited_without_api, :inherited
-            alias_method :web_service_api_without_require, :web_service_api
-          end
-        end
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        # Creates a client for accessing remote web services, using the
-        # given +protocol+ to communicate with the +endpoint_uri+.
-        #
-        # ==== Example
-        #
-        #   class MyController < ActionController::Base
-        #     web_client_api :blogger, :xmlrpc, "http://blogger.com/myblog/api/RPC2", :handler_name => 'blogger'
-        #   end
-        #
-        # In this example, a protected method named <tt>blogger</tt> will
-        # now exist on the controller, and calling it will return the
-        # XML-RPC client object for working with that remote service.
-        #
-        # +options+ is the set of protocol client specific options,
-        # see a protocol client class for details.
-        #
-        # If your API definition does not exist on the load path with the
-        # correct rules for it to be found using +name+, you can pass through
-        # the API definition class in +options+, using a key of <tt>:api</tt>
-        def web_client_api(name, protocol, endpoint_uri, options={})
-          unless method_defined?(name)
-            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)
-              end
-              protected name
-            end
-          end
-        end
-
-        def web_service_api(definition=nil) # :nodoc:
-          return web_service_api_without_require if definition.nil?
-          case definition
-          when String, Symbol
-            klass = require_web_service_api(definition)
-          else
-            klass = definition
-          end
-          web_service_api_without_require(klass)
-        end
-
-        def require_web_service_api(name) # :nodoc:
-          case name
-          when String, Symbol
-            file_name = name.to_s.underscore + "_api"
-            class_name = file_name.camelize
-            class_names = [class_name, class_name.sub(/Api$/, 'API')]
-            begin
-              require_dependency(file_name)
-            rescue LoadError => load_error
-              requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
-              raise LoadError, requiree == file_name ? "Missing API definition file in apis/#{file_name}.rb" : "Can't load file: #{requiree}"
-            end
-            klass = nil
-            class_names.each do |name|
-              klass = name.constantize rescue nil
-              break unless klass.nil?
-            end
-            unless klass
-              raise(NameError, "neither #{class_names[0]} or #{class_names[1]} found")
-            end
-            klass
-          else
-            raise(ArgumentError, "expected String or Symbol argument")
-          end
-        end
-
-        private
-          def inherited(child)
-            inherited_without_api(child)
-            child.web_service_api(child.controller_path)
-          rescue Exception => e
-          end
-      end
-    end
-  end
-end
diff --git a/actionwebservice/lib/action_web_service/api/abstract.rb b/actionwebservice/lib/action_web_service/api/base.rb
index 0ce68d10f7..952c6baa0d 100644
--- a/actionwebservice/lib/action_web_service/api/abstract.rb
+++ b/actionwebservice/lib/action_web_service/api/base.rb
@@ -1,70 +1,5 @@
 module ActionWebService # :nodoc:
   module API # :nodoc:
-    class APIError < ActionWebService::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(APIError, "symbols can only be used for #web_service_api inside of a controller")
-          end
-          unless definition.respond_to?(:ancestors) && definition.ancestors.include?(Base)
-            raise(APIError, "#{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
-
     # A web service API class specifies the methods that will be available for
     # invocation for an API. It also contains metadata such as the method type
     # signature hints.
@@ -87,8 +22,6 @@ module ActionWebService # :nodoc:
       private_class_method :new, :allocate
       
       class << self
-        include ActionWebService::Signature
-
         # API methods have a +name+, which must be the Ruby method name to use when
         # performing the invocation on the web service object.
         #
@@ -125,11 +58,11 @@ module ActionWebService # :nodoc:
             expects = options[:expects]
             returns = options[:returns]
           end
-          expects = canonical_signature(expects) if expects
-          returns = canonical_signature(returns) if returns
+          expects = canonical_signature(expects)
+          returns = canonical_signature(returns)
           if expects
             expects.each do |param|
-              klass = signature_parameter_class(param)
+              klass = WS::BaseTypes.canonical_param_type_class(param)
               klass = klass[0] if klass.is_a?(Array)
               if klass.ancestors.include?(ActiveRecord::Base)
                 raise(ActionWebServiceError, "ActiveRecord model classes not allowed in :expects")
@@ -186,6 +119,10 @@ module ActionWebService # :nodoc:
             end
           end
 
+          def canonical_signature(signature)
+            return nil if signature.nil?
+            signature.map{|spec| WS::BaseTypes.canonical_param_type_spec(spec)}
+          end
       end
     end
   end