Ousted ActionWebService from Rails 2.0

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

3 files changed, 0 insertions, 248 deletions

diff --git a/actionwebservice/lib/action_web_service/container/action_controller_container.rb b/actionwebservice/lib/action_web_service/container/action_controller_container.rb
deleted file mode 100644
index bbc28083c3..0000000000
--- a/actionwebservice/lib/action_web_service/container/action_controller_container.rb
+++ /dev/null
@@ -1,93 +0,0 @@
-module ActionWebService # :nodoc:
-  module Container # :nodoc:
-    module ActionController # :nodoc:
-      def self.included(base) # :nodoc:
-        class << base
-          include ClassMethods
-          alias_method_chain :inherited, :api
-          alias_method_chain :web_service_api, :require
-        end
-      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 in
-        # the API definition class via +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
-                create_web_service_client(api_klass, protocol, endpoint_uri, options)
-              end
-              protected name
-            end
-          end
-        end
-
-        def web_service_api_with_require(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]
-              msg = requiree == file_name ? "Missing API definition file in apis/#{file_name}.rb" : "Can't load file: #{requiree}"
-              raise LoadError.new(msg).copy_blame!(load_error)
-            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_with_api(child)
-            inherited_without_api(child)
-            begin child.web_service_api(child.controller_path)
-            rescue MissingSourceFile => e
-              raise unless e.is_missing?("apis/#{child.controller_path}_api")
-            end
-          end
-      end
-    end
-  end
-end
diff --git a/actionwebservice/lib/action_web_service/container/delegated_container.rb b/actionwebservice/lib/action_web_service/container/delegated_container.rb
deleted file mode 100644
index 5477f8d103..0000000000
--- a/actionwebservice/lib/action_web_service/container/delegated_container.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-module ActionWebService # :nodoc:
-  module Container # :nodoc:
-    module Delegated # :nodoc:
-      class ContainerError < ActionWebServiceError # :nodoc:
-      end
-  
-      def self.included(base) # :nodoc:
-        base.extend(ClassMethods)
-        base.send(:include, ActionWebService::Container::Delegated::InstanceMethods)
-      end
-  
-      module ClassMethods
-        # Declares a web service that will provide 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 ? self.instance_eval(&service) : info[:object]
-        end
-      end
-    end
-  end
-end
diff --git a/actionwebservice/lib/action_web_service/container/direct_container.rb b/actionwebservice/lib/action_web_service/container/direct_container.rb
deleted file mode 100644
index 8818d8f459..0000000000
--- a/actionwebservice/lib/action_web_service/container/direct_container.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-module ActionWebService # :nodoc:
-  module Container # :nodoc:
-    module Direct # :nodoc:
-      class ContainerError < ActionWebServiceError # :nodoc:
-      end
-
-      def self.included(base) # :nodoc:
-        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