keeguon-actionwebservice 3.1.1 → 3.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f32ed2010ad383912faba630b0b490c6fb1c340
-  data.tar.gz: b4cc523f99b1dd3f56a6f8d40aa28a4d449e4dd5
+  metadata.gz: 61d6e96218d9ff3f1a0b1346fa481a583ba2324a
+  data.tar.gz: f8b72ce64ac3b4daba29c084b4f84aa19604d2b7
 SHA512:
-  metadata.gz: 078de0a728373f4c40a2370cec186b519ea6040c06f64d44e0286c960597df7546e5e98e7cacbdebfb15b1c55978e404a5fbd91a98a0cb4237d8ac0951b44fa3
-  data.tar.gz: 85c0e82477c686b11e695d3b04d5cd1fbd051b89237f95b2320a7cbd8e30546a447787674518fd4156674b9017e56efe34b5db829f0ce97c95374c0e17f41148
+  metadata.gz: 7c2722574fff39bbced78313de244d1f0a3da84d74de1c9e08f8011c0f94f06080b8556bc549fd2c3da14890fe80ee2e470a362f7cb6bac55d7e8bb5c9ad3149
+  data.tar.gz: 33edac77e9d4179375e4c91c97678a6e20e85e39951bdbb37ff2fc964edb532d01fc1ea3f9d9683e5ac03b5f00fe05e4b771c79cb89572af9c1a463ea50862ac

data/Rakefile

@@ -1,9 +1,9 @@
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rake/packagetask'
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 require 'rake/contrib/rubyforgepublisher'
 require 'fileutils'
 require File.join(File.dirname(__FILE__), 'lib', 'action_web_service', 'version')
@@ -97,7 +97,7 @@ spec = Gem::Specification.new do |s|
   s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
   s.files = s.files + Dir.glob( "generators/**/*" ).delete_if { |item| item.match( /\.(svn|git)/ ) }
 end
-Rake::GemPackageTask.new(spec) do |p|
+Gem::PackageTask.new(spec) do |p|
   p.gem_spec = spec
   p.need_tar = true
   p.need_zip = true

data/lib/action_web_service.rb

@@ -23,19 +23,12 @@
 #++
 
 
-begin
-  require 'activesupport'
-  require 'actioncontroller'
-  require 'activerecord'
-  require 'actionpack'
-  require 'active_support/core_ext/class/inheritable_attributes'
-  require 'action_dispatch/routing'
-rescue LoadError
-  require 'rubygems'
-  gem 'activesupport', '>=3.0.5'
-  gem 'actionpack'   , '>=3.0.5'
-  gem 'activerecord' , '>=3.0.5'
-end
+require 'active_support'
+require 'action_controller'
+require 'active_record'
+require 'action_pack'
+require 'active_support/core_ext/class'
+require 'action_dispatch/routing'
 
 $:.unshift(File.dirname(__FILE__) + "/action_web_service/vendor/")
 

data/lib/action_web_service/api.rb

@@ -35,9 +35,11 @@ module ActionWebService # :nodoc:
       # Disallow instantiation
       private_class_method :new, :allocate
       
+      class_attribute :api_methods_attr, :api_public_method_names_attr, :default_api_method_instance_attr
+      self.api_methods_attr = self.api_public_method_names_attr = {}
+
       class << self
         include ActionWebService::SignatureTypes
-
         # API methods have a +name+, which must be the Ruby method name to use when
         # performing the invocation on the web service object.
         #
@@ -92,8 +94,8 @@ module ActionWebService # :nodoc:
           name = name.to_sym
           public_name = public_api_method_name(name)
           method = Method.new(name, public_name, expects, returns)
-          write_inheritable_hash("api_methods", name => method)
-          write_inheritable_hash("api_public_method_names", public_name => name)
+          self.api_methods_attr = self.api_methods_attr.merge({ name => method })
+          self.api_public_method_names_attr = self.api_public_method_names_attr.merge({ public_name => name })
         end
 
         # Whether the given method name is a service method on this API
@@ -105,7 +107,7 @@ module ActionWebService # :nodoc:
         #   ProjectsApi.has_api_method?('GetCount')   #=> false
         #   ProjectsApi.has_api_method?(:getCount)    #=> true
         def has_api_method?(name)
-          api_methods.has_key?(name)
+          self.api_methods_attr.has_key?(name)
         end
   
         # Whether the given public method name has a corresponding service method
@@ -118,7 +120,7 @@ module ActionWebService # :nodoc:
         #   ProjectsApi.has_api_method?(:getCount)    #=> false
         #   ProjectsApi.has_api_method?('GetCount')   #=> true
         def has_public_api_method?(public_name)
-          api_public_method_names.has_key?(public_name)
+          self.api_public_method_names_attr.has_key?(public_name)
         end
   
         # The corresponding public method name for the given service method name
@@ -141,7 +143,7 @@ module ActionWebService # :nodoc:
         #        
         #   ProjectsApi.api_method_name('GetCount') #=> :getCount
         def api_method_name(public_name)
-          api_public_method_names[public_name]
+          self.api_public_method_names_attr[public_name]
         end
   
         # A Hash containing all service methods on this API, and their
@@ -157,7 +159,7 @@ module ActionWebService # :nodoc:
         #      :getCompletedCount=>#<ActionWebService::API::Method:0x2437794 ...>}
         #   ProjectsApi.api_methods[:getCount].public_name #=> "GetCount"
         def api_methods
-          read_inheritable_attribute("api_methods") || {}
+          self.api_methods_attr
         end
 
         # The Method instance for the given public API method name, if any
@@ -189,18 +191,18 @@ module ActionWebService # :nodoc:
         # The Method instance for the default API method, if any
         def default_api_method_instance
           return nil unless name = default_api_method
-          instance = read_inheritable_attribute("default_api_method_instance")
+          instance = self.default_api_method_instance_attr
           if instance && instance.name == name
             return instance
           end
           instance = Method.new(name, public_api_method_name(name), nil, nil)
-          write_inheritable_attribute("default_api_method_instance", instance)
+          self.default_api_method_instance_attr = instance
           instance
         end
 
         private
           def api_public_method_names
-            read_inheritable_attribute("api_public_method_names") || {}
+            self.api_public_method_names_attr || {}
           end
   
           def validate_options(valid_option_keys, supplied_option_keys)

data/lib/action_web_service/container/delegated_container.rb

@@ -8,6 +8,9 @@ module ActionWebService # :nodoc:
       def self.included(base) # :nodoc:
         base.extend(ClassMethods)
         base.send(:include, ActionWebService::Container::Delegated::InstanceMethods)
+        base.class_attribute :web_services, :web_service_definition_callbacks
+        base.web_services = {}
+        base.web_service_definition_callbacks = []
       end
   
       module ClassMethods
@@ -47,7 +50,7 @@ module ActionWebService # :nodoc:
           else
             info = { name => { :object => object } }
           end
-          write_inheritable_hash("web_services", info)
+          self.web_services = self.web_services.merge(info)
           call_web_service_definition_callbacks(self, name, info)
         end
   
@@ -56,17 +59,13 @@ module ActionWebService # :nodoc:
           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])
+          self.web_service_definition_callbacks = self.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|
+            self.web_service_definition_callbacks.each do |block|
               block.call(container_class, web_service_name, service_info)
             end
           end

data/lib/action_web_service/container/direct_container.rb

@@ -7,6 +7,8 @@ module ActionWebService # :nodoc:
 
       def self.included(base) # :nodoc:
         base.extend(ClassMethods)
+        base.class_attribute :web_service_api_callbacks, :web_service_api_attr
+        base.web_service_api_callbacks = []
       end
   
       module ClassMethods
@@ -41,7 +43,7 @@ module ActionWebService # :nodoc:
         #   end
         def web_service_api(definition=nil)
           if definition.nil?
-            read_inheritable_attribute("web_service_api")
+            self.web_service_api_attr
           else
             if definition.is_a?(Symbol)
               raise(ContainerError, "symbols can only be used for #web_service_api inside of a controller")
@@ -49,18 +51,18 @@ module ActionWebService # :nodoc:
             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)
+            self.web_service_api_attr = 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])
+          self.web_service_api_callbacks = self.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|
+            self.web_service_api_callbacks.each do |block|
               block.call(container_class, definition)
             end
           end

data/lib/action_web_service/dispatcher/action_controller_dispatcher.rb

@@ -63,18 +63,18 @@ module ActionWebService # :nodoc:
               end
               log_request(ws_request, request.raw_post)
               if exception
-                Rails.logger.debug(exception) unless Rails.logger.nil?
+                Rails.logger.error(exception) unless logger.nil?
                 send_web_service_error_response(ws_request, exception)
               else
                 send_web_service_response(ws_response, bm.real)
               end
             else
               exception ||= DispatcherError.new("Malformed SOAP or XML-RPC protocol message")
-              Rails.logger.debug(exception) unless Rails.logger.nil?
+              Rails.logger.error(exception) unless logger.nil?
               send_web_service_error_response(ws_request, exception)
             end
           rescue Exception => e
-            Rails.logger.debug(e) unless Rails.logger.nil?
+            Rails.logger.error(e) unless logger.nil?
             send_web_service_error_response(ws_request, e)
           end
 
@@ -114,7 +114,7 @@ module ActionWebService # :nodoc:
           end
 
           def log_request(ws_request, body)
-            unless Rails.logger.nil?
+            unless logger.nil?
               name = ws_request.method_name
               api_method = ws_request.api_method
               params = ws_request.method_params
@@ -124,16 +124,16 @@ module ActionWebService # :nodoc:
                 params = params.map{ |param| param.inspect }
               end
               service = ws_request.service_name
-              Rails.logger.debug("\nWeb Service Request: #{name}(#{params.join(", ")}) Entrypoint: #{service}")
-              Rails.logger.debug(indent(body))
+              logger.debug("\nWeb Service Request: #{name}(#{params.join(", ")}) Entrypoint: #{service}")
+              logger.debug(indent(body))
             end
           end
 
           def log_response(ws_response, elapsed=nil)
-            unless Rails.logger.nil?
+            unless logger.nil?
               elapsed = (elapsed ? " (%f):" % elapsed : ":")
-              Rails.logger.debug("\nWeb Service Response" + elapsed + " => #{ws_response.return_value.inspect}")
-              Rails.logger.debug(indent(ws_response.body))
+              logger.debug("\nWeb Service Response" + elapsed + " => #{ws_response.return_value.inspect}")
+              logger.debug(indent(ws_response.body))
             end
           end
 
@@ -155,8 +155,7 @@ module ActionWebService # :nodoc:
               options = { :type => 'text/xml', :disposition => 'inline' }
               send_data(to_wsdl, options)
             rescue Exception => e
-              Rails.logger.debug(e) unless Rails.logger.nil?
-              throw e
+              Rails.logger.error(e) unless logger.nil?
             end
           elsif request.post?
             render :status => 500, :text => 'POST not supported'
@@ -166,7 +165,7 @@ module ActionWebService # :nodoc:
         private
           def base_uri
             host = request.host_with_port
-            relative_url_root = Rails.configuration.action_controller[:relative_url_root]
+            relative_url_root = self.config.relative_url_root
             scheme = request.ssl? ? 'https' : 'http'
             '%s://%s%s/%s/' % [scheme, host, relative_url_root, self.class.controller_path]
           end
@@ -184,7 +183,7 @@ module ActionWebService # :nodoc:
             case dispatching_mode
             when :direct
               api = self.class.web_service_api
-              web_service_name = controller_name.sub(/Controller$/, '').underscore
+              web_service_name = self.class.name.sub(/Controller$/, '').underscore
               apis[web_service_name] = [api, register_api(api, marshaler)]
             when :delegated, :layered
               self.class.web_services.each do |web_service_name, info|

data/lib/action_web_service/invocation.rb

@@ -7,6 +7,10 @@ module ActionWebService # :nodoc:
     def self.included(base) # :nodoc:
       base.extend(ClassMethods)
       base.send(:include, ActionWebService::Invocation::InstanceMethods)
+      base.class_attribute :included_intercepted_methods, :excluded_intercepted_methods
+      base.included_intercepted_methods = base.excluded_intercepted_methods = {}
+      base.class_attribute :before_invocation_interceptors_attr, :after_invocation_interceptors_attr
+      base.before_invocation_interceptors_attr = after_invocation_interceptors_attr = []
     end
 
     # Invocation interceptors provide a means to execute custom code before
@@ -82,29 +86,24 @@ module ActionWebService # :nodoc:
       alias :after_invocation :append_after_invocation
 
       def before_invocation_interceptors # :nodoc:
-        read_inheritable_attribute("before_invocation_interceptors")
+        self.before_invocation_interceptors_attr
       end
 
       def after_invocation_interceptors # :nodoc:
-        read_inheritable_attribute("after_invocation_interceptors")
-      end
-
-      def included_intercepted_methods # :nodoc:
-        read_inheritable_attribute("included_intercepted_methods") || {}
-      end
-      
-      def excluded_intercepted_methods # :nodoc:
-        read_inheritable_attribute("excluded_intercepted_methods") || {}
+        self.after_invocation_interceptors_attr
       end
 
       private
         def append_interceptors_to_chain(condition, interceptors)
-          write_inheritable_array("#{condition}_invocation_interceptors", interceptors)
+          meth = "#{condition}_invocation_interceptors_attr"
+          self.send("#{meth}=", self.send(meth) + interceptors)
         end
 
         def prepend_interceptors_to_chain(condition, interceptors)
-          interceptors = interceptors + read_inheritable_attribute("#{condition}_invocation_interceptors")
-          write_inheritable_attribute("#{condition}_invocation_interceptors", interceptors)
+          meth = "#{condition}_invocation_interceptors_attr"
+          interceptors = interceptors + self.send(meth)
+
+          self.send("#{meth}=", self.send(meth) + interceptors)
         end
 
         def extract_conditions!(interceptors)
@@ -115,8 +114,8 @@ module ActionWebService # :nodoc:
         def add_interception_conditions(interceptors, conditions)
           return unless conditions
           included, excluded = conditions[:only], conditions[:except]
-          write_inheritable_hash("included_intercepted_methods", condition_hash(interceptors, included)) && return if included
-          write_inheritable_hash("excluded_intercepted_methods", condition_hash(interceptors, excluded)) if excluded
+          self.included_intercepted_methods = self.included_intercepted_methods.merge(condition_hash(interceptors, included)) && return if included
+          self.excluded_intercepted_methods = self.excluded_intercepted_methods.merge(condition_hash(interceptors, excluded)) if excluded
         end
 
         def condition_hash(interceptors, *methods)

data/lib/action_web_service/protocol/discovery.rb

@@ -5,18 +5,20 @@ module ActionWebService # :nodoc:
       def self.included(base)
         base.extend(ClassMethods)
         base.send(:include, ActionWebService::Protocol::Discovery::InstanceMethods)
+        base.class_attribute :web_service_protocols
+        base.web_service_protocols = []
       end
 
       module ClassMethods # :nodoc:
         def register_protocol(klass)
-          write_inheritable_array("web_service_protocols", [klass])
+          self.web_service_protocols = self.web_service_protocols + [klass]
         end
       end
 
       module InstanceMethods # :nodoc:
         private
           def discover_web_service_request(action_pack_request)
-            (self.class.read_inheritable_attribute("web_service_protocols") || []).each do |protocol|
+            self.class.web_service_protocols.each do |protocol|
               protocol = protocol.create(self)
               request = protocol.decode_action_pack_request(action_pack_request)
               return request unless request.nil?
@@ -25,7 +27,7 @@ module ActionWebService # :nodoc:
           end
 
           def create_web_service_client(api, protocol_name, endpoint_uri, options)
-            (self.class.read_inheritable_attribute("web_service_protocols") || []).each do |protocol|
+            self.class.web_service_protocols.each do |protocol|
               protocol = protocol.create(self)
               client = protocol.protocol_client(api, protocol_name, endpoint_uri, options)
               return client unless client.nil?

data/lib/action_web_service/protocol/soap_protocol.rb

@@ -155,10 +155,23 @@ module ActionWebService # :nodoc:
             soap_action.gsub!(/^"/, '')
             soap_action.gsub!(/"$/, '')
             soap_action.strip!
+            soap_action = get_action_from_envelope(request.env["RAW_POST_DATA"]) if soap_action.empty?
             return nil if soap_action.empty?
             soap_action
           end
 
+          # Allow for consumers that do not send the method name in the
+          # HTTP_SOAPACTION http header. In this mode the method name is in the
+          # XML tag under Envelope/Body in the Soap request.  Without this
+          # change, Rails is unable to determine the method name unless it's
+          # provided in HTTP_SOAPACTION.
+          # TODO: Find out which clients do this and comment them here.
+          def get_action_from_envelope(data)
+            require 'nokogiri'
+            node = Nokogiri.XML(data).xpath("/*[local-name()='Envelope']/*[local-name()='Body']/*[1]").first
+            (node.nil? || node.name.nil?) ? "" : node.name.strip
+          end
+
           def create_soap_envelope(body)
             header = SOAP::SOAPHeader.new
             body = SOAP::SOAPBody.new(body)

data/lib/action_web_service/simple.rb

@@ -25,26 +25,27 @@ module ActionWebService
       @value = value
     end
     
+    class_attribute :simple_restrictions, :xml_base
+    self.simple_restrictions = {}
+    self.xml_base = ""
+
     class << self
       def base(type)
         type = type.to_s.camelize(:lower)
-        write_inheritable_attribute("xml_base", type)
-        class_eval <<-END
-          def xml_base; "#{type}"; end
-        END
+        self.xml_base = type
       end
       
       def restriction_base
-        read_inheritable_attribute("xml_base") || ""
+        self.xml_base
       end
       
       def restriction(type, value)
         type = type.to_s.camelize(:lower)
-        write_inheritable_hash("simple_restrictions", type => value)
+        self.simple_restrictions = self.simple_restrictions.merge({ type => value })
       end
       
       def restrictions
-        read_inheritable_attribute("simple_restrictions") || {}
+        self.simple_restrictions
       end
       
     end

data/lib/action_web_service/struct.rb

@@ -42,6 +42,9 @@ module ActionWebService
       end
     end
 
+    class_attribute :struct_members
+    self.struct_members = {}
+
     class << self
       # Creates a structure member with the specified +name+ and +type+. Additional wsdl
       # schema properties may be specified in the optional hash +options+. Generates
@@ -49,7 +52,7 @@ module ActionWebService
       def member(name, type, options={})
         name = name.to_sym
         type = ActionWebService::SignatureTypes.canonical_signature_entry({ name => type }, 0)
-        write_inheritable_hash("struct_members", name => [type, options])
+        self.struct_members = self.struct_members.merge({ name => [type, options] })
         class_eval <<-END
           def #{name}; @#{name}; end
           def #{name}=(value); @#{name} = value; end
@@ -57,7 +60,7 @@ module ActionWebService
       end
   
       def members # :nodoc:
-        read_inheritable_attribute("struct_members") || {}
+        self.struct_members
       end
 
       def member_type(name) # :nodoc:

data/lib/action_web_service/support/class_inheritable_options.rb

@@ -1,27 +1,27 @@
 # encoding: UTF-8
 class Class # :nodoc:
   def class_inheritable_option(sym, default_value=nil)
-    class_attribute sym
-
+    class_attribute "#{sym}_attr"
+    self.send("#{sym}_attr=", default_value) if default_value
     class_eval <<-EOS
       def self.#{sym}(value=nil)
-        class_attribute :#{sym}
         if !value.nil?
-          self.#{sym} = value
+          self.#{sym}_attr = value
+        else
+          self.#{sym}_attr
         end
       end
       
       def self.#{sym}=(value)
-        class_attribute :#{sym}
-        self.#{sym} = value
+        self.#{sym}_attr = value
       end
 
       def #{sym}
-        self.class.#{sym}
+        self.class.#{sym}_attr
       end
 
       def #{sym}=(value)
-        self.class.#{sym} = value
+        self.class.#{sym}_attr = value
       end
     EOS
   end

data/lib/action_web_service/test_invoke.rb

@@ -1,111 +1,107 @@
 # encoding: UTF-8
-require 'test/unit'
 
-module Test # :nodoc:
-  module Unit # :nodoc:
-    class TestCase # :nodoc:
-      private
-        # invoke the specified API method
-        def invoke_direct(method_name, *args)
-          prepare_request('api', 'api', method_name, *args)
-          @controller.process(@request, @response)
-          decode_rpc_response
-        end
-        alias_method :invoke, :invoke_direct
+module ActionWebServiceInvokeHelper
+  private
+  # invoke the specified API method
+  def invoke_direct(method_name, *args)
+    prepare_request('api', 'api', method_name, *args)
+    @controller.dispatch('api', @request, @response)
+    decode_rpc_response
+  end
+  alias_method :invoke, :invoke_direct
 
-        # invoke the specified API method on the specified service
-        def invoke_delegated(service_name, method_name, *args)
-          prepare_request(service_name.to_s, service_name, method_name, *args)
-          @controller.process(@request, @response)
-          decode_rpc_response
-        end
+  # invoke the specified API method on the specified service
+  def invoke_delegated(service_name, method_name, *args)
+    prepare_request(service_name.to_s, service_name, method_name, *args)
+    @controller.dispatch('api', @request, @response)
+    decode_rpc_response
+  end
 
-        # invoke the specified layered API method on the correct service
-        def invoke_layered(service_name, method_name, *args)
-          prepare_request('api', service_name, method_name, *args)
-          @controller.process(@request, @response)
-          decode_rpc_response
-        end
+  # invoke the specified layered API method on the correct service
+  def invoke_layered(service_name, method_name, *args)
+    prepare_request('api', service_name, method_name, *args)
+    @controller.dispatch('api', @request, @response)
+    decode_rpc_response
+  end
 
-        # ---------------------- internal ---------------------------
+  # ---------------------- internal ---------------------------
 
-        def prepare_request(action, service_name, api_method_name, *args)
-          @request.recycle!
-          @request.request_parameters['action'] = action
-          @request.env['REQUEST_METHOD'] = 'POST'
-          @request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
-          @request.env['RAW_POST_DATA'] = encode_rpc_call(service_name, api_method_name, *args)
-          case protocol
-          when ActionWebService::Protocol::Soap::SoapProtocol
-            soap_action = "/#{@controller.controller_name}/#{service_name}/#{public_method_name(service_name, api_method_name)}" 
-            @request.env['HTTP_SOAPACTION'] = soap_action
-          when ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
-            @request.env.delete('HTTP_SOAPACTION')
-          end
-        end
+  def prepare_request(action, service_name, api_method_name, *args)
+    @request.recycle!
+    @request.request_parameters['action'] = action
+    @request.request_parameters['controller'] = @controller.class.name
+    @request.env['REQUEST_METHOD'] = 'POST'
+    @request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
+    @request.env['RAW_POST_DATA'] = encode_rpc_call(service_name, api_method_name, *args)
+    case protocol
+    when ActionWebService::Protocol::Soap::SoapProtocol
+      soap_action = "/#{@controller.controller_name}/#{service_name}/#{public_method_name(service_name, api_method_name)}"
+      @request.env['HTTP_SOAPACTION'] = soap_action
+    when ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
+      @request.env.delete('HTTP_SOAPACTION')
+    end
+  end
 
-        def encode_rpc_call(service_name, api_method_name, *args)
-          case @controller.web_service_dispatching_mode
-          when :direct
-            api = @controller.class.web_service_api
-          when :delegated, :layered
-            api = @controller.web_service_object(service_name.to_sym).class.web_service_api
-          end
-          protocol.register_api(api)
-          method = api.api_methods[api_method_name.to_sym]
-          raise ArgumentError, "wrong number of arguments for rpc call (#{args.length} for #{method.expects.length})" if method && method.expects && args.length != method.expects.length
-          protocol.encode_request(public_method_name(service_name, api_method_name), args.dup, method.expects)
-        end
+  def encode_rpc_call(service_name, api_method_name, *args)
+    case @controller.web_service_dispatching_mode
+    when :direct
+      api = @controller.class.web_service_api
+    when :delegated, :layered
+      api = @controller.web_service_object(service_name.to_sym).class.web_service_api
+    end
+    protocol.register_api(api)
+    method = api.api_methods[api_method_name.to_sym]
+    raise ArgumentError, "wrong number of arguments for rpc call (#{args.length} for #{method.expects.length})" if method && method.expects && args.length != method.expects.length
+    protocol.encode_request(public_method_name(service_name, api_method_name), args.dup, method.expects)
+  end
 
-        def decode_rpc_response
-          public_method_name, return_value = protocol.decode_response(@response.body)
-          exception = is_exception?(return_value)
-          raise exception if exception
-          return_value
-        end
+  def decode_rpc_response
+    public_method_name, return_value = protocol.decode_response(@response.body)
+    exception = is_exception?(return_value)
+    raise exception if exception
+    return_value
+  end
 
-        def public_method_name(service_name, api_method_name)
-          public_name = service_api(service_name).public_api_method_name(api_method_name)
-          if @controller.web_service_dispatching_mode == :layered && protocol.is_a?(ActionWebService::Protocol::XmlRpc::XmlRpcProtocol)
-            '%s.%s' % [service_name.to_s, public_name]
-          else
-            public_name
-          end
-        end
+  def public_method_name(service_name, api_method_name)
+    public_name = service_api(service_name).public_api_method_name(api_method_name)
+    if @controller.web_service_dispatching_mode == :layered && protocol.is_a?(ActionWebService::Protocol::XmlRpc::XmlRpcProtocol)
+      '%s.%s' % [service_name.to_s, public_name]
+    else
+      public_name
+    end
+  end
 
-        def service_api(service_name)
-          case @controller.web_service_dispatching_mode
-          when :direct
-            @controller.class.web_service_api
-          when :delegated, :layered
-            @controller.web_service_object(service_name.to_sym).class.web_service_api
-          end
-        end
+  def service_api(service_name)
+    case @controller.web_service_dispatching_mode
+    when :direct
+      @controller.class.web_service_api
+    when :delegated, :layered
+      @controller.web_service_object(service_name.to_sym).class.web_service_api
+    end
+  end
 
-        def protocol
-          if @protocol.nil?
-            @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
-          else
-            case @protocol
-            when :xmlrpc
-              @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.create(@controller)
-            when :soap
-              @protocol = ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
-            else
-              @protocol
-            end
-          end
-        end
+  def protocol
+    if @protocol.nil?
+      @protocol ||= ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
+    else
+      case @protocol
+      when :xmlrpc
+        @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.create(@controller)
+      when :soap
+        @protocol = ActionWebService::Protocol::Soap::SoapProtocol.create(@controller)
+      else
+        @protocol
+      end
+    end
+  end
 
-        def is_exception?(obj)
-          case protocol
-          when :soap, ActionWebService::Protocol::Soap::SoapProtocol
-            (obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && \
-            obj.detail.cause.is_a?(Exception)) ? obj.detail.cause : nil
-          when :xmlrpc, ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
-            obj.is_a?(XMLRPC::FaultException) ? obj : nil
-          end
-        end
+  def is_exception?(obj)
+    case protocol
+    when :soap, ActionWebService::Protocol::Soap::SoapProtocol
+      (obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && \
+          obj.detail.cause.is_a?(Exception)) ? obj.detail.cause : nil
+    when :xmlrpc, ActionWebService::Protocol::XmlRpc::XmlRpcProtocol
+      obj.is_a?(XMLRPC::FaultException) ? obj : nil
     end
   end
 end

metadata

@@ -1,59 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: keeguon-actionwebservice
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors:
-- Laurence A. Lee, Leon Breedt, Kent Sibilev
+- Laurence A. Lee
+- Leon Breedt
+- Kent Sibilev
+- Félix Bellanger
 autorequire: actionwebservice
 bindir: bin
 cert_chain: []
-date: 2013-04-04 00:00:00.000000000 Z
+date: 2013-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 description: Adds WSDL/SOAP and XML-RPC web service support to Action Pack
-email: rubyjedi@gmail.com, bitserf@gmail.com, ksibilev@yahoo.com
+email:
+- rubyjedi@gmail.com
+- bitserf@gmail.com
+- ksibilev@yahoo.com
+- felix.bellanger@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []