Checkout of Instiki Trunk 1/21/2007.

vendor/rails/actionwebservice/lib/action_web_service/container/action_controller_container.rb

@@ -0,0 +1,95 @@
+module ActionWebService # :nodoc:
+  module Container # :nodoc:
+    module ActionController # :nodoc:
+      def self.append_features(base) # :nodoc:
+        class << base
+          include ClassMethods
+          alias_method :inherited_without_api, :inherited
+          alias_method :inherited, :inherited_with_api
+          alias_method :web_service_api_without_require, :web_service_api
+          alias_method :web_service_api, :web_service_api_with_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

vendor/rails/actionwebservice/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 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

vendor/rails/actionwebservice/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