actionwebservice 0.7.1 → 0.8.0

data/CHANGELOG

@@ -1,3 +1,36 @@
+*0.8.0* (6 July, 2005)
+
+* Fix WSDL generation by aliasing #inherited instead of trying to overwrite it, or the WSDL action may end up not being defined in the controller
+
+* Add ActionController::Base.wsdl_namespace option, to allow overriding of the namespace used in generated WSDL and SOAP messages. This is equivalent to the [WebService(Namespace = "Value")] attribute in .NET.
+
+* Add workaround for Ruby 1.8.3's SOAP4R changing the return value of SOAP::Mapping::Registry#find_mapped_soap_class #1414 [Shugo Maeda]
+
+* Fix moduled controller URLs in WSDL, and add unit test to verify the generated URL #1428
+
+* Fix scaffolding template paths, it was broken on Win32
+
+* Fix that functional testing of :layered controllers failed when using the SOAP protocol
+
+* Allow invocation filters in :direct controllers as well, as they have access to more information regarding the web service request than ActionPack filters
+
+* Add support for a :base64 signature type #1272 [Shugo Maeda]
+
+* Fix that boolean fields were not rendered correctly in scaffolding
+
+* Fix that scaffolding was not working for :delegated dispatching
+
+* Add support for structured types as input parameters to scaffolding, this should let one test the blogging APIs using scaffolding as well
+
+* Fix that generated WSDL was not using relative_url_root for base URI #1210 [Shugo Maeda]
+
+* Use UTF-8 encoding by default for SOAP responses, but if an encoding is supplied by caller, use that for the response  #1211 [Shugo Maeda, NAKAMURA Hiroshi]
+
+* If the WSDL was retrieved over HTTPS, use HTTPS URLs in the WSDL too
+
+* Fix that casting change in 0.7.0 would convert nil values to the default value for the type instead of leaving it as nil
+
+
 *0.7.1* (20th April, 2005)
 
 * Depend on Active Record 1.10.1 and Action Pack 1.8.1

data/README

@@ -78,15 +78,15 @@ modes of dispatching protocol requests, _Direct_, and _Delegated_.
 
 === Direct dispatching
 
-This is the default mode. In this mode, controller actions implement the API
-methods, and parameters for incoming method calls will be placed in
-<tt>@params</tt> (keyed by name), and <tt>@method_params</tt> (ordered list).
+This is the default mode. In this mode, public controller instance methods
+implement the API methods, and parameters are passed through to the methods in
+accordance with the API specification.
 
-The return value of the action is sent back as the return value to the
+The return value of the method is sent back as the return value to the
 caller.
 
 In this mode, a special <tt>api</tt> action is generated in the target
-controller to unwrap the protocol request, forward it on to the relevant action
+controller to unwrap the protocol request, forward it on to the relevant method
 and send back the wrapped return value. <em>This action must not be
 overridden.</em>
 
@@ -108,7 +108,7 @@ overridden.</em>
 
 
 For this example, protocol requests for +Add+ and +Remove+ methods sent to
-<tt>/person/api</tt> will be routed to the actions +add+ and +remove+.
+<tt>/person/api</tt> will be routed to the controller methods +add+ and +remove+.
 
 
 === Delegated dispatching
@@ -196,6 +196,25 @@ For this example, an XML-RPC call for a method with a name like
 method on the <tt>:mt</tt> service.
 
 
+== Customizing WSDL generation
+
+You can customize the names used for the SOAP bindings in the generated
+WSDL by using the wsdl_service_name option in a controller:
+
+  class WsController < ApplicationController
+    wsdl_service_name 'MyApp'
+  end
+
+You can also customize the namespace used in the generated WSDL for
+custom types and message definition types:
+
+  class WsController < ApplicationController
+    wsdl_namespace 'http://my.company.com/app/wsapi'
+  end
+
+The default namespace used is 'urn:ActionWebService', if you don't supply
+one.
+
 == Testing your APIs
 
 

data/Rakefile

@@ -9,7 +9,7 @@ require 'fileutils'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'actionwebservice'
-PKG_VERSION   = '0.7.1' + PKG_BUILD
+PKG_VERSION   = '0.8.0' + PKG_BUILD
 PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
 
@@ -62,9 +62,9 @@ spec = Gem::Specification.new do |s|
   s.rubyforge_project = "aws"
   s.homepage = "http://www.rubyonrails.org"
 
-  s.add_dependency('actionpack', '= 1.8.1' + PKG_BUILD)
-  s.add_dependency('activerecord', '= 1.10.1' + PKG_BUILD)
-  s.add_dependency('activesupport', '= 1.0.4' + PKG_BUILD)
+  s.add_dependency('actionpack', '= 1.9.0' + PKG_BUILD)
+  s.add_dependency('activerecord', '= 1.11.0' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.1.0' + PKG_BUILD)
 
   s.has_rdoc = true
   s.requirements << 'none'
@@ -86,14 +86,14 @@ end
 # Publish beta gem
 desc "Publish the API documentation"
 task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh davidhh@wrath.rubyonrails.com './gemupdate.sh'`
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
 end
 
 # Publish documentation
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.com", "public_html/aws", "doc").upload
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/aws", "doc").upload
 end
 
 

data/TODO

@@ -1,10 +1,31 @@
-= 0.8.0
-  - Allow locking down a controller to only accept messages for a particular protocol.
-    This will allow us to generate fully conformant error messages in cases where we
-    currently fudge it if we don't know the protocol.
+= Post-1.0
+  - Document/Literal SOAP support
+    - URL-based dispatching, URL identifies method
 
-  - Allow AWS user to participate in typecasting, so they can centralize workarounds
-    for buggy input in one place
+  - Add :rest dispatching mode, a.l.a. Backpack API. Clean up dispatching
+    in general. Support vanilla XML-format as a "Rails" protocol?
+    XML::Simple deserialization into params?
+
+      web_service_dispatching_mode :rest
+
+      def method1(params)
+      end
+
+      def method2(params)
+      end
+
+
+      /ws/method1
+        <xml>
+      /ws/method2
+        <yaml>
+
+  - Allow locking down a controller to only accept messages for a particular
+    protocol.  This will allow us to generate fully conformant error messages
+    in cases where we currently fudge it if we don't know the protocol.
+
+  - Allow AWS user to participate in typecasting, so they can centralize
+    workarounds for buggy input in one place
   
 = Refactoring
   - Don't have clean way to go from SOAP Class object to the xsd:NAME type

data/lib/action_web_service.rb

@@ -59,6 +59,7 @@ ActionController::Base.class_eval do
   include ActionWebService::Container::Direct
   include ActionWebService::Container::Delegated
   include ActionWebService::Container::ActionController
+  include ActionWebService::Invocation
   include ActionWebService::Dispatcher
   include ActionWebService::Dispatcher::ActionController
   include ActionWebService::Scaffolding

data/lib/action_web_service/api.rb

@@ -8,7 +8,11 @@ module ActionWebService # :nodoc:
     #
     # It is attached to web service implementation classes like
     # ActionWebService::Base and ActionController::Base derivatives by using
-    # ClassMethods#web_service_api.
+    # <tt>container.web_service_api</tt>, where <tt>container</tt> is an
+    # ActionController::Base or a ActionWebService::Base.
+    #
+    # See ActionWebService::Container::Direct::ClassMethods for an example
+    # of use.
     class Base
       # Whether to transform the public API method names into camel-cased names 
       class_inheritable_option :inflect_names, true
@@ -40,7 +44,7 @@ module ActionWebService # :nodoc:
         # A parameter specifier can be one of the following:
         #
         # * A symbol or string of representing one of the Action Web Service base types.
-        #   See ActionWebService::Signature for a canonical list of the base types.
+        #   See ActionWebService::SignatureTypes 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 Web Service to treat the parameter at that position
@@ -217,9 +221,9 @@ module ActionWebService # :nodoc:
       # String representation of this method
       def to_s
         fqn = ""
-        fqn << (@returns ? (friendly_param(@returns[0], false) + " ") : "void ")
+        fqn << (@returns ? (@returns[0].human_name(false) + " ") : "void ")
         fqn << "#{@public_name}("
-        fqn << @expects.map{ |p| friendly_param(p) }.join(", ") if @expects
+        fqn << @expects.map{ |p| p.human_name }.join(", ") if @expects
         fqn << ")"
         fqn
       end
@@ -236,13 +240,6 @@ module ActionWebService # :nodoc:
             end
           end
         end
-
-        def friendly_param(type, show_name=true)
-          name = type.name.to_s
-          type_type = type.array?? type.element_type.type.to_s : type.type.to_s
-          str = type.array?? (type_type + '[]') : type_type
-          show_name ? (str + " " + name) : str
-        end
     end
   end
 end

data/lib/action_web_service/casting.rb

@@ -7,7 +7,7 @@ module ActionWebService # :nodoc:
     end
 
     # Performs casting of arbitrary values into the correct types for the signature
-    class BaseCaster
+    class BaseCaster # :nodoc:
       def initialize(api_method)
         @api_method = api_method
       end
@@ -39,6 +39,7 @@ module ActionWebService # :nodoc:
 
         def cast(value, signature_type) # :nodoc:
           return value if signature_type.nil? # signature.length != params.length
+          return nil if value.nil?
           unless signature_type.array? || signature_type.structured?
             return value if canonical_type(value.class) == signature_type.type
           end
@@ -62,6 +63,12 @@ module ActionWebService # :nodoc:
             Integer(value)
           when :string
             value.to_s
+          when :base64
+            if value.is_a?(ActionWebService::Base64)
+              value
+            else
+              ActionWebService::Base64.new(value.to_s)
+            end
           when :bool
             return false if value.nil?
             return value if value == true || value == false

data/lib/action_web_service/client/soap_client.rb

@@ -24,10 +24,10 @@ module ActionWebService # :nodoc:
       # will be sent with HTTP POST.
       #
       # Valid options:
-      # [<tt>:type_namespace</tt>]    If the remote server has used a custom namespace to
-      #                               declare its custom types, you can specify it here
-      # [<tt>:method_namespace</tt>]  If the remote server has used a custom namespace to
-      #                               declare its methods, you can specify it here
+      # [<tt>:namespace</tt>]    If the remote server has used a custom namespace to
+      #                          declare its custom types, you can specify it here. This would
+      #                          be the namespace declared with a [WebService(Namespace = "http://namespace")] attribute
+      #                          in .NET, for example.
       # [<tt>:driver_options</tt>]    If you want to supply any custom SOAP RPC driver
       #                               options, you can provide them as a Hash here
       #
@@ -43,10 +43,9 @@ module ActionWebService # :nodoc:
       #   client = ActionWebService::Client::Soap.new(api, 'https://some/service', :driver_options => opts)
       def initialize(api, endpoint_uri, options={})
         super(api, endpoint_uri)
-        @type_namespace = options[:type_namespace] || 'urn:ActionWebService'
-        @method_namespace = options[:method_namespace] || 'urn:ActionWebService'
+        @namespace = options[:namespace] || 'urn:ActionWebService'
         @driver_options = options[:driver_options] || {}
-        @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new
+        @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new @namespace
         @soap_action_base = options[:soap_action_base]
         @soap_action_base ||= URI.parse(endpoint_uri).path
         @driver = create_soap_rpc_driver(api, endpoint_uri)
@@ -73,7 +72,7 @@ module ActionWebService # :nodoc:
           driver = SoapDriver.new(endpoint_uri, nil)
           driver.mapping_registry = @protocol.marshaler.registry
           api.api_methods.each do |name, method|
-            qname = XSD::QName.new(@method_namespace, method.public_name)
+            qname = XSD::QName.new(@namespace, method.public_name)
             action = soap_action(method.public_name)
             expects = method.expects
             returns = method.returns

data/lib/action_web_service/container/action_controller_container.rb

@@ -2,13 +2,13 @@ module ActionWebService # :nodoc:
   module Container # :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
+        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
-        base.extend(ClassMethods)
       end
 
       module ClassMethods
@@ -43,7 +43,7 @@ module ActionWebService # :nodoc:
           end
         end
 
-        def web_service_api(definition=nil) # :nodoc:
+        def web_service_api_with_require(definition=nil) # :nodoc:
           return web_service_api_without_require if definition.nil?
           case definition
           when String, Symbol
@@ -82,7 +82,7 @@ module ActionWebService # :nodoc:
         end
 
         private
-          def inherited(child)
+          def inherited_with_api(child)
             inherited_without_api(child)
             begin child.web_service_api(child.controller_path)
             rescue MissingSourceFile => e

data/lib/action_web_service/container/delegated_container.rb

@@ -35,7 +35,7 @@ module ActionWebService # :nodoc:
         #   class ApiController < ApplicationController
         #     web_service_dispatching_mode :delegated
         #
-        #     web_service(:person) { PersonService.new(@request.env) }
+        #     web_service(:person) { PersonService.new(request.env) }
         #   end
         def web_service(name, object=nil, &block)
           if (object && block_given?) || (object.nil? && block.nil?)

data/lib/action_web_service/dispatcher/abstract.rb

@@ -28,28 +28,33 @@ module ActionWebService # :nodoc:
           @method_params = invocation.method_ordered_params
           arity = method(invocation.api_method.name).arity rescue 0
           if arity < 0 || arity > 0
-            return_value = self.__send__(invocation.api_method.name, *@method_params)
+            params = @method_params
           else
-            return_value = self.__send__(invocation.api_method.name)
+            params = []
           end
-          web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value)
+          web_service_filtered_invoke(invocation, params)
         end
 
         def web_service_delegated_invoke(invocation)
+          web_service_filtered_invoke(invocation, invocation.method_ordered_params)
+        end
+
+        def web_service_filtered_invoke(invocation, params)
           cancellation_reason = nil
-          return_value = invocation.service.perform_invocation(invocation.api_method.name, invocation.method_ordered_params) do |x|
+          return_value = invocation.service.perform_invocation(invocation.api_method.name, params) do |x|
             cancellation_reason = x
           end
           if cancellation_reason
             raise(DispatcherError, "request canceled: #{cancellation_reason}")
           end
-          web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value)
+          web_service_create_response(invocation.protocol, invocation.protocol_options, invocation.api, invocation.api_method, return_value)
         end
 
         def web_service_invocation(request)
           public_method_name = request.method_name
           invocation = Invocation.new
           invocation.protocol = request.protocol
+          invocation.protocol_options = request.protocol_options
           invocation.service_name = request.service_name
           if web_service_dispatching_mode == :layered
             case invocation.protocol
@@ -109,18 +114,19 @@ module ActionWebService # :nodoc:
           invocation
         end
 
-        def web_service_create_response(protocol, api, api_method, return_value)
+        def web_service_create_response(protocol, protocol_options, api, api_method, return_value)
           if api.has_api_method?(api_method.name)
             return_type = api_method.returns ? api_method.returns[0] : nil
             return_value = api_method.cast_returns(return_value)
           else
             return_type = ActionWebService::SignatureTypes.canonical_signature_entry(return_value.class, 0)
           end
-          protocol.encode_response(api_method.public_name + 'Response', return_value, return_type)
+          protocol.encode_response(api_method.public_name + 'Response', return_value, return_type, protocol_options)
         end
 
         class Invocation # :nodoc:
           attr_accessor :protocol
+          attr_accessor :protocol_options
           attr_accessor :service_name
           attr_accessor :api
           attr_accessor :api_method

data/lib/action_web_service/dispatcher/action_controller_dispatcher.rb

@@ -6,10 +6,12 @@ module ActionWebService # :nodoc:
     module ActionController # :nodoc:
       def self.append_features(base) # :nodoc:
         super
+        class << base
+          include ClassMethods
+          alias_method :inherited_without_action_controller, :inherited
+          alias_method :inherited, :inherited_with_action_controller
+        end
         base.class_eval do
-          class << self
-            alias_method :inherited_without_action_controller, :inherited
-          end
           alias_method :web_service_direct_invoke_without_controller, :web_service_direct_invoke
         end
         base.add_web_service_api_callback do |klass, api|
@@ -24,12 +26,11 @@ module ActionWebService # :nodoc:
             klass.class_eval 'def api; dispatch_web_service_request; end'
           end
         end
-        base.extend(ClassMethods)
         base.send(:include, ActionWebService::Dispatcher::ActionController::InstanceMethods)
       end
 
       module ClassMethods # :nodoc:
-        def inherited(child)
+        def inherited_with_action_controller(child)
           inherited_without_action_controller(child)
           child.send(:include, ActionWebService::Dispatcher::ActionController::WsdlAction)
         end
@@ -40,53 +41,53 @@ module ActionWebService # :nodoc:
           def dispatch_web_service_request
             exception = nil
             begin
-              request = discover_web_service_request(@request)
+              ws_request = discover_web_service_request(request)
             rescue Exception => e
               exception = e
             end
-            if request
-              response = nil
+            if ws_request
+              ws_response = nil
               exception = nil
               bm = Benchmark.measure do
                 begin
-                  response = invoke_web_service_request(request)
+                  ws_response = invoke_web_service_request(ws_request)
                 rescue Exception => e
                   exception = e
                 end
               end
-              log_request(request, @request.raw_post)
+              log_request(ws_request, request.raw_post)
               if exception
                 log_error(exception) unless logger.nil?
-                send_web_service_error_response(request, exception)
+                send_web_service_error_response(ws_request, exception)
               else
-                send_web_service_response(response, bm.real)
+                send_web_service_response(ws_response, bm.real)
               end
             else
               exception ||= DispatcherError.new("Malformed SOAP or XML-RPC protocol message")
               log_error(exception) unless logger.nil?
-              send_web_service_error_response(request, exception)
+              send_web_service_error_response(ws_request, exception)
             end
           rescue Exception => e
             log_error(e) unless logger.nil?
-            send_web_service_error_response(request, e)
+            send_web_service_error_response(ws_request, e)
           end
 
-          def send_web_service_response(response, elapsed=nil)
-            log_response(response, elapsed)
-            options = { :type => response.content_type, :disposition => 'inline' }
-            send_data(response.body, options)
+          def send_web_service_response(ws_response, elapsed=nil)
+            log_response(ws_response, elapsed)
+            options = { :type => ws_response.content_type, :disposition => 'inline' }
+            send_data(ws_response.body, options)
           end
 
-          def send_web_service_error_response(request, exception)
-            if request
+          def send_web_service_error_response(ws_request, exception)
+            if ws_request
               unless self.class.web_service_exception_reporting
                 exception = DispatcherError.new("Internal server error (exception raised)")
               end
-              api_method = request.api_method
-              public_method_name = api_method ? api_method.public_name : request.method_name
+              api_method = ws_request.api_method
+              public_method_name = api_method ? api_method.public_name : ws_request.method_name
               return_type = ActionWebService::SignatureTypes.canonical_signature_entry(Exception, 0)
-              response = request.protocol.encode_response(public_method_name + 'Response', exception, return_type)
-              send_web_service_response(response)
+              ws_response = ws_request.protocol.encode_response(public_method_name + 'Response', exception, return_type, ws_request.protocol_options)
+              send_web_service_response(ws_response)
             else
               if self.class.web_service_exception_reporting
                 message = exception.message
@@ -100,13 +101,10 @@ module ActionWebService # :nodoc:
           end
 
           def web_service_direct_invoke(invocation)
-            @params ||= {}
             invocation.method_named_params.each do |name, value|
-              @params[name] = value
+              params[name] = value
             end
-            @session ||= {}
-            @assigns ||= {}
-            @params['action'] = invocation.api_method.name.to_s
+            params['action'] = invocation.api_method.name.to_s
             if before_action == false
               raise(DispatcherError, "Method filtered")
             end
@@ -115,27 +113,27 @@ module ActionWebService # :nodoc:
             return_value
           end
 
-          def log_request(request, body)
+          def log_request(ws_request, body)
             unless logger.nil?
-              name = request.method_name
-              api_method = request.api_method
-              params = request.method_params
+              name = ws_request.method_name
+              api_method = ws_request.api_method
+              params = ws_request.method_params
               if api_method && api_method.expects
                 params = api_method.expects.zip(params).map{ |type, param| "#{type.name}=>#{param.inspect}" }
               else
                 params = params.map{ |param| param.inspect }
               end
-              service = request.service_name
+              service = ws_request.service_name
               logger.debug("\nWeb Service Request: #{name}(#{params.join(", ")}) Entrypoint: #{service}")
               logger.debug(indent(body))
             end
           end
 
-          def log_response(response, elapsed=nil)
+          def log_response(ws_response, elapsed=nil)
             unless logger.nil?
               elapsed = (elapsed ? " (%f):" % elapsed : ":")
-              logger.debug("\nWeb Service Response" + elapsed + " => #{response.return_value.inspect}")
-              logger.debug(indent(response.body))
+              logger.debug("\nWeb Service Response" + elapsed + " => #{ws_response.return_value.inspect}")
+              logger.debug(indent(ws_response.body))
             end
           end
 
@@ -152,7 +150,7 @@ module ActionWebService # :nodoc:
         SoapHttpTransport = 'http://schemas.xmlsoap.org/soap/http'
 
         def wsdl
-          case @request.method
+          case request.method
           when :get
             begin
               options = { :type => 'text/xml', :disposition => 'inline' }
@@ -167,15 +165,17 @@ module ActionWebService # :nodoc:
 
         private
           def base_uri
-            host = @request ? (@request.env['HTTP_HOST'] || @request.env['SERVER_NAME']) : 'localhost'
-            'http://%s/%s/' % [host, controller_name]
+            host = request.env['HTTP_HOST'] || request.env['SERVER_NAME'] || 'localhost'
+            relative_url_root = request.relative_url_root
+            scheme = request.ssl? ? 'https' : 'http'
+            '%s://%s%s/%s/' % [scheme, host, relative_url_root, self.class.controller_path]
           end
 
           def to_wsdl
             xml = ''
             dispatching_mode = web_service_dispatching_mode
             global_service_name = wsdl_service_name
-            namespace = 'urn:ActionWebService'
+            namespace = wsdl_namespace || 'urn:ActionWebService'
             soap_action_base = "/#{controller_name}"
 
             marshaler = ActionWebService::Protocol::Soap::SoapMarshaler.new(namespace)