Renamed Action Service to Action Web Service

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

2 files changed, 0 insertions, 284 deletions

diff --git a/actionservice/lib/action_service/api/abstract.rb b/actionservice/lib/action_service/api/abstract.rb
deleted file mode 100644
index aab37a285d..0000000000
--- a/actionservice/lib/action_service/api/abstract.rb
+++ /dev/null
@@ -1,192 +0,0 @@
-module ActionService # :nodoc:
-  module API # :nodoc:
-    class APIError < ActionService::ActionServiceError # :nodoc:
-    end
-
-    def self.append_features(base) # :nodoc:
-      super
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      # Attaches ActionService 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 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 < ActionService::Base
-      #     web_service_api MyAPI
-      #   end
-      #
-      #   class MyAPI < ActionService::API::Base
-      #     ...
-      #   end
-      #
-      # ==== Controller class example
-      #
-      #   class MyController < ActionController::Base
-      #     web_service_api MyAPI
-      #   end
-      #
-      #   class MyAPI < ActionService::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.
-    #
-    # It is not intended to be instantiated.
-    #
-    # It is attached to web service implementation classes like
-    # ActionService::Base and ActionController::Base derivatives by using
-    # ClassMethods#web_service_api.
-    class Base
-      # Whether to transform the public API method names into camel-cased names 
-      class_inheritable_option :inflect_names, true
-
-      # If present, the name of a method to call when the remote caller
-      # tried to call a nonexistent method. Semantically equivalent to
-      # +method_missing+.
-      class_inheritable_option :default_api_method
-
-      # Disallow instantiation
-      private_class_method :new, :allocate
-      
-      class << self
-        include ActionService::Signature
-
-        # API methods have a +name+, which must be the Ruby method name to use when
-        # performing the invocation on the web service object.
-        #
-        # The signatures for the method input parameters and return value can
-        # by specified in +options+.
-        #
-        # A signature is an array of one or more parameter specifiers. 
-        # A parameter specifier can be one of the following:
-        #
-        # * A symbol or string of representing one of the Action Service base types.
-        #   See ActionService::Signature for a canonical list of the base types.
-        # * The Class object of the parameter type
-        # * A single-element Array containing one of the two preceding items. This
-        #   will cause Action Service to treat the parameter at that position
-        #   as an array containing only values of the given type.
-        # * A Hash containing as key the name of the parameter, and as value
-        #   one of the three preceding items
-        # 
-        # If no method input parameter or method return value signatures are given,
-        # the method is assumed to take no parameters and/or return no values of
-        # interest, and any values that are received by the server will be
-        # discarded and ignored.
-        #
-        # Valid options:
-        # [<tt>:expects</tt>]             Signature for the method input parameters
-        # [<tt>:returns</tt>]             Signature for the method return value
-        # [<tt>:expects_and_returns</tt>] Signature for both input parameters and return value
-        def api_method(name, options={})
-          validate_options([:expects, :returns, :expects_and_returns], options.keys)
-          if options[:expects_and_returns]
-            expects = options[:expects_and_returns]
-            returns = options[:expects_and_returns]
-          else
-            expects = options[:expects]
-            returns = options[:returns]
-          end
-          expects = canonical_signature(expects) if expects
-          returns = canonical_signature(returns) if returns
-          if expects
-            expects.each do |param|
-              klass = signature_parameter_class(param)
-              klass = klass[0] if klass.is_a?(Array)
-              if klass.ancestors.include?(ActiveRecord::Base)
-                raise(ActionServiceError, "ActiveRecord model classes not allowed in :expects")
-              end
-            end
-          end
-          name = name.to_sym
-          public_name = public_api_method_name(name)
-          info = { :expects => expects, :returns => returns }
-          write_inheritable_hash("api_methods", name => info)
-          write_inheritable_hash("api_public_method_names", public_name => name)
-        end
-
-        # Whether the given method name is a service method on this API
-        def has_api_method?(name)
-          api_methods.has_key?(name)
-        end
-  
-        # Whether the given public method name has a corresponding service method
-        # on this API
-        def has_public_api_method?(public_name)
-          api_public_method_names.has_key?(public_name)
-        end
-  
-        # The corresponding public method name for the given service method name
-        def public_api_method_name(name)
-          if inflect_names
-            name.to_s.camelize
-          else
-            name.to_s
-          end
-        end
-  
-        # The corresponding service method name for the given public method name
-        def api_method_name(public_name)
-          api_public_method_names[public_name]
-        end
-  
-        # A Hash containing all service methods on this API, and their
-        # associated metadata.
-        def api_methods
-          read_inheritable_attribute("api_methods") || {}
-        end
-  
-        private
-          def api_public_method_names
-            read_inheritable_attribute("api_public_method_names") || {}
-          end
-  
-          def validate_options(valid_option_keys, supplied_option_keys)
-            unknown_option_keys = supplied_option_keys - valid_option_keys
-            unless unknown_option_keys.empty?
-              raise(ActionServiceError, "Unknown options: #{unknown_option_keys}")
-            end
-          end
-
-      end
-    end
-  end
-end
diff --git a/actionservice/lib/action_service/api/action_controller.rb b/actionservice/lib/action_service/api/action_controller.rb
deleted file mode 100644
index d603f3a570..0000000000
--- a/actionservice/lib/action_service/api/action_controller.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-module ActionService # :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