actionservice 0.2.102 → 0.3.0

data/lib/action_service/protocol/soap.rb

@@ -5,13 +5,13 @@ require 'xsd/datatypes'
 require 'xsd/ns'
 require 'singleton'
 
-module ActionService
-  module Protocol
-    module Soap
-      class ProtocolError < ActionService::ActionServiceError
+module ActionService # :nodoc:
+  module Protocol # :nodoc:
+    module Soap # :nodoc:
+      class ProtocolError < ActionService::ActionServiceError # :nodoc:
       end
 
-      def self.append_features(base)
+      def self.append_features(base) # :nodoc:
         super
         base.register_protocol(HeaderAndBody, SoapProtocol)
         base.extend(ClassMethods)
@@ -19,16 +19,24 @@ module ActionService
       end
 
       module ClassMethods
+        # Specifies the WSDL service name to use when generating WSDL. Highly
+        # recommended that you set this value, or code generators may generate
+        # classes with very generic names.
+        #
+        # === Example
+        #   class ApiController < ActionController::Base
+        #     wsdl_service_name 'Test'
+        #   end
         def wsdl_service_name(name)
           write_inheritable_attribute("soap_mapper", SoapMapper.new("urn:#{name}"))
         end
 
-        def soap_mapper
+        def soap_mapper # :nodoc:
           read_inheritable_attribute("soap_mapper")
         end
       end
 
-      class SoapProtocol < AbstractProtocol
+      class SoapProtocol < AbstractProtocol # :nodoc:
         def self.create_protocol_request(container_class, action_pack_request)
           soap_action = extract_soap_action(action_pack_request)
           return nil unless soap_action
@@ -178,7 +186,7 @@ module ActionService
           end
       end
 
-      class SoapMapper
+      class SoapMapper # :nodoc:
         attr :registry
         attr :custom_namespace
         attr :custom_types
@@ -383,7 +391,7 @@ module ActionService
           end
       end
 
-      class SoapMapping
+      class SoapMapping # :nodoc:
         attr :ruby_klass
         attr :generated_klass
         attr :soap_klass
@@ -440,7 +448,7 @@ module ActionService
         end
       end
   
-      class SoapArrayMapping < SoapMapping
+      class SoapArrayMapping < SoapMapping # :nodoc:
         attr :element_mapping
   
         def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping, element_mapping)

data/lib/action_service/protocol/xmlrpc.rb

@@ -1,36 +1,41 @@
 require 'xmlrpc/parser'
+require 'xmlrpc/create'
+require 'xmlrpc/config'
 require 'xmlrpc/utils'
 require 'singleton'
 
-module ActionService
-  module Protocol
-    module XmlRpc
-      def self.append_features(base)
+module XMLRPC # :nodoc:
+  class XmlRpcHelper # :nodoc:
+    include Singleton
+    include ParserWriterChooseMixin
+
+    def parse_method_call(message)
+      parser().parseMethodCall(message)
+    end
+
+    def create_method_response(successful, return_value)
+      create().methodResponse(successful, return_value)
+    end
+  end
+end
+
+module ActionService # :nodoc:
+  module Protocol # :nodoc:
+    module XmlRpc # :nodoc:
+      def self.append_features(base) # :nodoc:
         super
         base.register_protocol(BodyOnly, XmlRpcProtocol)
       end
 
-      class XmlRpcProtocol < AbstractProtocol
-        private
-          class Helper
-            include Singleton
-            include XMLRPC::ParserWriterChooseMixin
-
-            def get_parser
-              parser()
-            end
-
-            def get_create
-              create()
-            end
-          end
+      class XmlRpcProtocol < AbstractProtocol # :nodoc:
 
         public
 
         def self.create_protocol_request(container_class, action_pack_request)
-          parser = Helper.instance.get_parser
+          helper = XMLRPC::XmlRpcHelper.instance
           service_name = action_pack_request.parameters['action']
-          methodname, params = parser.parseMethodCall(action_pack_request.raw_post)
+          methodname, params = helper.parse_method_call(action_pack_request.raw_post)
+          methodname.gsub!(/^[^\.]+\./, '') unless methodname =~ /^system\./ # XXX
           protocol = XmlRpcProtocol.new(container_class)
           content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
           content_type ||= 'text/xml'
@@ -38,8 +43,8 @@ module ActionService
                                         action_pack_request.raw_post,
                                         service_name.to_sym,
                                         methodname,
-                                        content_type)
-          request.values = params
+                                        content_type,
+                                        :xmlrpc_values => params)
           request
         rescue
           nil
@@ -51,10 +56,11 @@ module ActionService
         end
 
         def unmarshal_request(protocol_request)
-          values = protocol_request.values
+          values = protocol_request.options[:xmlrpc_values]
           signature = protocol_request.signature
           if signature
             signature = array_types(signature)
+            values = transform_expected_params(signature, values)
             protocol_request.check_parameter_types(values, signature)
             values
           else
@@ -63,30 +69,31 @@ module ActionService
         end
   
         def marshal_response(protocol_request, return_value)
-          create = Helper.instance.get_create
+          helper = XMLRPC::XmlRpcHelper.instance
           signature = protocol_request.return_signature
           if signature
             signature = array_types(signature)
             protocol_request.check_parameter_types([return_value], signature)
-            return_value = fixup_values_for_return(return_value)
-            raw_response = create.methodResponse(true, return_value)
+            return_value = transform_return_value(return_value)
+            raw_response = helper.create_method_response(true, return_value)
           else
             # XML-RPC doesn't have the concept of a void method, nor does it
             # support a nil return value, so return true if we would have returned
             # nil
             if protocol_request.checked?
-              raw_response = create.methodResponse(true, true)
+              raw_response = helper.create_method_response(true, true)
             else
               return_value = true if return_value.nil?
-              raw_response = create.methodResponse(true, return_value)
+              raw_response = helper.create_method_response(true, return_value)
             end
           end
           ProtocolResponse.new(self, raw_response, 'text/xml')
         end
   
         def marshal_exception(exception)
-          create = Helper.instance.get_create
-          raw_response = create.methodResponse(false, exception)
+          helper = XMLRPC::XmlRpcHelper.instance
+          exception = XMLRPC::FaultException.new(1, exception.message)
+          raw_response = helper.create_method_response(false, exception)
           ProtocolResponse.new(self, raw_response, 'text/xml')
         end
   
@@ -108,14 +115,40 @@ module ActionService
             signature.map{|x| x.is_a?(Array) ? Array : x}
           end
 
-          def fixup_values_for_return(return_value)
+          def transform_expected_params(signature, params)
+            (1..signature.size).each do |i|
+              i -= 1
+              if signature[i].ancestors.include?(ActionService::Struct)
+                if params[i].class.ancestors.include?(Hash)
+                  new_param = signature[i].new
+                  signature[i].members.each do |name, klass|
+                    new_param.send('%s=' % name.to_s, params[i][name.to_s])
+                  end
+                  params[i] = new_param
+                else
+                  raise(ProtocolError, "expected input parameter #{i+1} to be a Hash")
+                end
+              end
+            end
+            params
+          end
+
+          def transform_return_value(return_value)
             if return_value.is_a?(Array)
               (1..return_value.size).each do |i|
-                return_value[i-1] = fixup_values_for_return(return_value[i-1])
+                return_value[i-1] = transform_return_value(return_value[i-1])
               end
             else
               if return_value.is_a?(ActiveRecord::Base)
                 return_value = return_value.instance_variable_get('@attributes')
+              elsif return_value.is_a?(ActionService::Struct)
+                struct = {}
+                return_value.class.members.each do |name, klass|
+                  value = return_value.send(name)
+                  next if value.nil?
+                  struct[name.to_s] = value
+                end
+                return_value = struct
               end
             end
             return_value

data/lib/action_service/router/action_controller.rb

@@ -1,7 +1,7 @@
-module ActionService
-  module Router
-    module ActionController
-      def self.append_features(base)
+module ActionService # :nodoc:
+  module Router # :nodoc:
+    module ActionController # :nodoc:
+      def self.append_features(base) # :nodoc:
         base.add_export_definition_callback do |klass, export_name, export_info|
           if klass.service_dispatching_mode == :direct && !klass.method_defined?(:api)
             klass.class_eval <<-EOS
@@ -23,16 +23,22 @@ module ActionService
         base.send(:include, ActionService::Router::ActionController::InstanceMethods)
       end
 
-      module InstanceMethods
+      module InstanceMethods # :nodoc:
         private
           def process_action_service_request
             protocol_request = nil
             begin
-              protocol_request = probe_request_protocol(self.request)
+              begin
+                protocol_request = probe_request_protocol(self.request)
+              rescue Exception => e
+                logger.error "Invalid request: #{e.message}"
+                logger.error self.request.raw_post
+                raise
+              end
               if protocol_request
                 log_request(protocol_request)
                 protocol_response = dispatch_service_request(protocol_request)
-                log_response(protocol_request)
+                log_response(protocol_response)
                 response_options = {
                   :type        => protocol_response.content_type,
                   :disposition => 'inline'
@@ -44,16 +50,24 @@ module ActionService
               end
             rescue Exception => e
               log_error e unless logger.nil?
-              service_object = service_object(protocol_request.service_name) rescue nil
               exc_response = nil
-              if service_object && service_object.class.report_exceptions
-                exc_response = protocol_request.protocol.marshal_exception(e) rescue nil
+              case service_dispatching_mode
+              when :direct
+                if self.class.report_exceptions
+                  exc_response = protocol_request.protocol.marshal_exception(e)
+                end
+              when :delegated
+                service_object = service_object(protocol_request.service_name) rescue nil
+                if service_object && service_object.class.report_exceptions
+                  exc_response = protocol_request.protocol.marshal_exception(e) rescue nil
+                end
               end
               if exc_response
                 response_options = {
                   :type        => exc_response.content_type,
                   :disposition => 'inline'
                 }
+                log_response exc_response
                 send_data(exc_response.raw_body, response_options)
               else
                 render_text 'Internal protocol error', "500 #{e.message}"

data/lib/action_service/router/wsdl.rb

@@ -1,11 +1,11 @@
-module ActionService
-  module Router
-    module Wsdl
-      def self.append_features(base)
+module ActionService # :nodoc:
+  module Router # :nodoc:
+    module Wsdl # :nodoc:
+      def self.append_features(base) # :nodoc:
         base.send(:include, ActionService::Router::Wsdl::InstanceMethods)
       end
 
-      module InstanceMethods
+      module InstanceMethods # :nodoc:
         XsdNs             = 'http://www.w3.org/2001/XMLSchema'
         WsdlNs            = 'http://schemas.xmlsoap.org/wsdl/'
         SoapNs            = 'http://schemas.xmlsoap.org/wsdl/soap/'

data/lib/action_service/struct.rb

@@ -1,5 +1,21 @@
 module ActionService
+  # To send structured types across the wire, derive from ActionService::Struct,
+  # and use +member+ to declare structure members.
+  #
+  # === Example
+  #
+  #   class Person < ActionService::Struct
+  #     member :firstnames, [String]
+  #     member :lastname, String
+  #     member :email, String
+  #   end
+  #
+  # Active Record model classes are already implicitly supported for return
+  # value signatures. A structure containing its columns as members will be
+  # automatically generated if its present in a signature.
   class Struct
+    # Creates a structure member accessible using +name+. Generates
+    # accessor methods for reading and writing the member value.
     def self.member(name, type)
       write_inheritable_hash("struct_members", name => type)
       class_eval <<-END
@@ -8,7 +24,7 @@ module ActionService
       END
     end
 
-    def self.members
+    def self.members # :nodoc:
       read_inheritable_attribute("struct_members") || {}
     end
   end

data/lib/action_service/support/class_inheritable_options.rb

@@ -1,4 +1,4 @@
-class Class
+class Class # :nodoc:
   def class_inheritable_option(sym, default_value=nil)
     write_inheritable_attribute sym, default_value
     class_eval <<-EOS

data/test/protocol_xmlrpc_test.rb

@@ -4,7 +4,7 @@ require 'xmlrpc/create'
 require 'xmlrpc/config'
 
 module XMLRPC
-  class XmlRpcHelper
+  class XmlRpcTestHelper
     include ParserWriterChooseMixin
   
     def create_request(methodName, *args)
@@ -18,6 +18,12 @@ module XMLRPC
 end
 
 module ProtocolXmlRpcTest
+  class Person < ActionService::Struct
+    member :firstname, String
+    member :lastname, String
+    member :active, TrueClass
+  end
+
   class Service < ActionService::Base
     attr :result
     attr :hashvalue
@@ -44,6 +50,14 @@ module ProtocolXmlRpcTest
     def hash_returner
       {'name' => 1, 'value' => 2}
     end
+
+    def struct_array_returner
+      person = Person.new
+      person.firstname = "John"
+      person.lastname = "Doe"
+      person.active = true
+      [person]
+    end
   
     def default(*args)
       @default_args = args
@@ -54,6 +68,7 @@ module ProtocolXmlRpcTest
     export :hash_returner,  :returns => [Hash]
     export :array_returner, :returns => [[Integer]]
     export :something_hash, :expects => [Hash]
+    export :struct_array_returner, :returns => [[Person]]
   
     default_export :default
   end
@@ -81,7 +96,7 @@ end
 
 class TC_ProtocolXmlRpc < Test::Unit::TestCase
   def setup
-    @helper = XMLRPC::XmlRpcHelper.new
+    @helper = XMLRPC::XmlRpcTestHelper.new
     @container = ProtocolXmlRpcTest::Container.new
   end
 
@@ -100,6 +115,11 @@ class TC_ProtocolXmlRpc < Test::Unit::TestCase
     assert(retval == [true, {'name' => 1, 'value' => 2}])
   end
 
+  def test_struct_array_returning
+    retval = do_xmlrpc_call('StructArrayReturner')
+    assert(retval == [true, [{"firstname"=>"John", "lastname"=>"Doe", "active"=>true}]])
+  end
+
   def test_hash_parameter
     retval = do_xmlrpc_call('SomethingHash', {'name' => 1, 'value' => 2})
     assert(retval == [true, true])
@@ -114,7 +134,7 @@ class TC_ProtocolXmlRpc < Test::Unit::TestCase
 
   def test_xmlrpc_introspection
     retval = do_xmlrpc_call('system.listMethods', 'test', [1, 2], {'name'=>'value'})
-    assert(retval == [true,  ["Add", "ArrayReturner", "HashReturner", "SomethingHash"]])
+    assert(retval == [true,  ["Add", "ArrayReturner", "HashReturner", "SomethingHash", "StructArrayReturner"]])
   end
 
   private

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.4
 specification_version: 1
 name: actionservice
 version: !ruby/object:Gem::Version 
-  version: 0.2.102
-date: 2005-02-12
+  version: 0.3.0
+date: 2005-02-13
 summary: Web service support for Action Pack.
 require_paths: 
   - lib
@@ -34,13 +34,16 @@ files:
   - HACKING
   - ChangeLog
   - MIT-LICENSE
-  - examples/soap
-  - examples/soap/lib
-  - examples/soap/README
-  - examples/soap/app
-  - examples/soap/lib/google_search_service.rb
-  - examples/soap/app/controllers
-  - examples/soap/app/controllers/search_controller.rb
+  - examples/metaWeblog
+  - examples/googlesearch
+  - examples/metaWeblog/blog_controller.rb
+  - examples/metaWeblog/README
+  - examples/googlesearch/README
+  - examples/googlesearch/direct
+  - examples/googlesearch/delegated
+  - examples/googlesearch/direct/search_controller.rb
+  - examples/googlesearch/delegated/google_search_service.rb
+  - examples/googlesearch/delegated/search_controller.rb
   - lib/action_service
   - lib/action_service.rb
   - lib/action_service/protocol