backlog 0.0.4 → 0.0.5

data/vendor/rails/actionwebservice/lib/action_web_service/invocation.rb

@@ -1,202 +0,0 @@
-module ActionWebService # :nodoc:
-  module Invocation # :nodoc:
-    class InvocationError < ActionWebService::ActionWebServiceError # :nodoc:
-    end
-
-    def self.included(base) # :nodoc:
-      base.extend(ClassMethods)
-      base.send(:include, ActionWebService::Invocation::InstanceMethods)
-    end
-
-    # Invocation interceptors provide a means to execute custom code before
-    # and after method invocations on ActionWebService::Base objects.
-    #
-    # When running in _Direct_ dispatching mode, ActionController filters
-    # should be used for this functionality instead.
-    #
-    # The semantics of invocation interceptors are the same as ActionController
-    # filters, and accept the same parameters and options.
-    #
-    # A _before_ interceptor can also cancel execution by returning +false+,
-    # or returning a <tt>[false, "cancel reason"]</tt> array if it wishes to supply
-    # a reason for canceling the request.
-    #
-    # === Example
-    #
-    #   class CustomService < ActionWebService::Base
-    #     before_invocation :intercept_add, :only => [:add]
-    #
-    #     def add(a, b)
-    #       a + b
-    #     end
-    #
-    #     private
-    #       def intercept_add
-    #         return [false, "permission denied"] # cancel it
-    #       end
-    #   end
-    #
-    # Options:
-    # [<tt>:except</tt>]  A list of methods for which the interceptor will NOT be called
-    # [<tt>:only</tt>]    A list of methods for which the interceptor WILL be called
-    module ClassMethods
-      # Appends the given +interceptors+ to be called
-      # _before_ method invocation.
-      def append_before_invocation(*interceptors, &block)
-        conditions = extract_conditions!(interceptors)
-        interceptors << block if block_given?
-        add_interception_conditions(interceptors, conditions)
-        append_interceptors_to_chain("before", interceptors)
-      end
-
-      # Prepends the given +interceptors+ to be called
-      # _before_ method invocation.
-      def prepend_before_invocation(*interceptors, &block)
-        conditions = extract_conditions!(interceptors)
-        interceptors << block if block_given?
-        add_interception_conditions(interceptors, conditions)
-        prepend_interceptors_to_chain("before", interceptors)
-      end
-
-      alias :before_invocation :append_before_invocation
-
-      # Appends the given +interceptors+ to be called
-      # _after_ method invocation.
-      def append_after_invocation(*interceptors, &block)
-        conditions = extract_conditions!(interceptors)
-        interceptors << block if block_given?
-        add_interception_conditions(interceptors, conditions)
-        append_interceptors_to_chain("after", interceptors)
-      end
-
-      # Prepends the given +interceptors+ to be called
-      # _after_ method invocation.
-      def prepend_after_invocation(*interceptors, &block)
-        conditions = extract_conditions!(interceptors)
-        interceptors << block if block_given?
-        add_interception_conditions(interceptors, conditions)
-        prepend_interceptors_to_chain("after", interceptors)
-      end
-
-      alias :after_invocation :append_after_invocation
-
-      def before_invocation_interceptors # :nodoc:
-        read_inheritable_attribute("before_invocation_interceptors")
-      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") || {}
-      end
-
-      private
-        def append_interceptors_to_chain(condition, interceptors)
-          write_inheritable_array("#{condition}_invocation_interceptors", interceptors)
-        end
-
-        def prepend_interceptors_to_chain(condition, interceptors)
-          interceptors = interceptors + read_inheritable_attribute("#{condition}_invocation_interceptors")
-          write_inheritable_attribute("#{condition}_invocation_interceptors", interceptors)
-        end
-
-        def extract_conditions!(interceptors)
-          return nil unless interceptors.last.is_a? Hash
-          interceptors.pop
-        end
-
-        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
-        end
-
-        def condition_hash(interceptors, *methods)
-          interceptors.inject({}) {|hash, interceptor| hash.merge(interceptor => methods.flatten.map {|method| method.to_s})}
-        end
-    end
-
-    module InstanceMethods # :nodoc:
-      def self.included(base)
-        base.class_eval do
-          alias_method_chain :perform_invocation, :interception
-        end
-      end
-
-      def perform_invocation_with_interception(method_name, params, &block)
-        return if before_invocation(method_name, params, &block) == false
-        return_value = perform_invocation_without_interception(method_name, params)
-        after_invocation(method_name, params, return_value)
-        return_value
-      end
-
-      def perform_invocation(method_name, params)
-        send(method_name, *params)
-      end
-
-      def before_invocation(name, args, &block)
-        call_interceptors(self.class.before_invocation_interceptors, [name, args], &block)
-      end
-
-      def after_invocation(name, args, result)
-        call_interceptors(self.class.after_invocation_interceptors, [name, args, result])
-      end
-
-      private
-
-        def call_interceptors(interceptors, interceptor_args, &block)
-          if interceptors and not interceptors.empty?
-            interceptors.each do |interceptor|
-              next if method_exempted?(interceptor, interceptor_args[0].to_s)
-              result = case
-                when interceptor.is_a?(Symbol)
-                  self.send(interceptor, *interceptor_args)
-                when interceptor_block?(interceptor)
-                  interceptor.call(self, *interceptor_args)
-                when interceptor_class?(interceptor)
-                  interceptor.intercept(self, *interceptor_args)
-                else
-                  raise(
-                    InvocationError,
-                    "Interceptors need to be either a symbol, proc/method, or a class implementing a static intercept method"
-                  )
-              end
-              reason = nil
-              if result.is_a?(Array)
-                reason = result[1] if result[1]
-                result = result[0]
-              end
-              if result == false
-                block.call(reason) if block && reason
-                return false
-              end
-            end
-          end
-        end
-
-        def interceptor_block?(interceptor)
-          interceptor.respond_to?("call") && (interceptor.arity == 3 || interceptor.arity == -1)
-        end
-        
-        def interceptor_class?(interceptor)
-          interceptor.respond_to?("intercept")
-        end
-
-        def method_exempted?(interceptor, method_name)
-          case
-            when self.class.included_intercepted_methods[interceptor]
-              !self.class.included_intercepted_methods[interceptor].include?(method_name)
-            when self.class.excluded_intercepted_methods[interceptor] 
-              self.class.excluded_intercepted_methods[interceptor].include?(method_name)
-          end
-        end
-    end
-  end
-end

data/vendor/rails/actionwebservice/lib/action_web_service/protocol.rb

@@ -1,4 +0,0 @@
-require 'action_web_service/protocol/abstract'
-require 'action_web_service/protocol/discovery'
-require 'action_web_service/protocol/soap_protocol'
-require 'action_web_service/protocol/xmlrpc_protocol'

data/vendor/rails/actionwebservice/lib/action_web_service/protocol/abstract.rb

@@ -1,112 +0,0 @@
-module ActionWebService # :nodoc:
-  module Protocol # :nodoc:
-    class ProtocolError < ActionWebServiceError # :nodoc:
-    end
-
-    class AbstractProtocol # :nodoc:
-      def setup(controller)
-      end
-
-      def decode_action_pack_request(action_pack_request)
-      end
-
-      def encode_action_pack_request(service_name, public_method_name, raw_body, options={})
-        klass = options[:request_class] || SimpleActionPackRequest
-        request = klass.new
-        request.request_parameters['action'] = service_name.to_s
-        request.env['RAW_POST_DATA'] = raw_body
-        request.env['REQUEST_METHOD'] = 'POST'
-        request.env['HTTP_CONTENT_TYPE'] = 'text/xml'
-        request
-      end
-
-      def decode_request(raw_request, service_name, protocol_options={})
-      end
-
-      def encode_request(method_name, params, param_types)
-      end
-
-      def decode_response(raw_response)
-      end
-
-      def encode_response(method_name, return_value, return_type, protocol_options={})
-      end
-
-      def protocol_client(api, protocol_name, endpoint_uri, options)
-      end
-
-      def register_api(api)
-      end
-    end
-
-    class Request # :nodoc:
-      attr :protocol
-      attr_accessor :method_name
-      attr_accessor :method_params
-      attr :service_name
-      attr_accessor :api
-      attr_accessor :api_method
-      attr :protocol_options
-
-      def initialize(protocol, method_name, method_params, service_name, api=nil, api_method=nil, protocol_options=nil)
-        @protocol = protocol
-        @method_name = method_name
-        @method_params = method_params
-        @service_name = service_name
-        @api = api
-        @api_method = api_method
-        @protocol_options = protocol_options || {}
-      end
-    end
-
-    class Response # :nodoc:
-      attr :body
-      attr :content_type
-      attr :return_value
-
-      def initialize(body, content_type, return_value)
-        @body = body
-        @content_type = content_type
-        @return_value = return_value
-      end
-    end
-
-    class SimpleActionPackRequest < ActionController::AbstractRequest # :nodoc:
-      def initialize
-        @env = {}
-        @qparams = {}
-        @rparams = {}
-        @cookies = {}
-        reset_session
-      end
-
-      def query_parameters
-        @qparams
-      end
-
-      def request_parameters
-        @rparams
-      end
-
-      def env
-        @env
-      end
-
-      def host
-        ''
-      end
-
-      def cookies
-        @cookies
-      end
-
-      def session
-        @session
-      end
-
-      def reset_session
-        @session = {}
-      end
-    end
-  end
-end

data/vendor/rails/actionwebservice/lib/action_web_service/protocol/discovery.rb

@@ -1,37 +0,0 @@
-module ActionWebService # :nodoc:
-  module Protocol # :nodoc:
-    module Discovery # :nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.send(:include, ActionWebService::Protocol::Discovery::InstanceMethods)
-      end
-
-      module ClassMethods # :nodoc:
-        def register_protocol(klass)
-          write_inheritable_array("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|
-              protocol = protocol.create(self)
-              request = protocol.decode_action_pack_request(action_pack_request)
-              return request unless request.nil?
-            end
-            nil
-          end
-
-          def create_web_service_client(api, protocol_name, endpoint_uri, options)
-            (self.class.read_inheritable_attribute("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?
-            end
-            nil
-          end
-      end
-    end
-  end
-end

data/vendor/rails/actionwebservice/lib/action_web_service/protocol/soap_protocol.rb

@@ -1,176 +0,0 @@
-require 'action_web_service/protocol/soap_protocol/marshaler'
-require 'soap/streamHandler'
-require 'action_web_service/client/soap_client'
-
-module ActionWebService # :nodoc:
-  module API # :nodoc:
-    class Base # :nodoc:
-      def self.soap_client(endpoint_uri, options={})
-        ActionWebService::Client::Soap.new self, endpoint_uri, options
-      end
-    end
-  end
-
-  module Protocol # :nodoc:
-    module Soap # :nodoc:
-      def self.included(base)
-        base.register_protocol(SoapProtocol)
-        base.class_inheritable_option(:wsdl_service_name)
-        base.class_inheritable_option(:wsdl_namespace)
-      end
-      
-      class SoapProtocol < AbstractProtocol # :nodoc:
-        AWSEncoding = 'UTF-8'
-        XSDEncoding = 'UTF8'
-
-        attr :marshaler
-
-        def initialize(namespace=nil)
-          namespace ||= 'urn:ActionWebService'
-          @marshaler = SoapMarshaler.new namespace
-        end
-
-        def self.create(controller)
-          SoapProtocol.new(controller.wsdl_namespace)
-        end
-
-        def decode_action_pack_request(action_pack_request)
-          return nil unless soap_action = has_valid_soap_action?(action_pack_request)
-          service_name = action_pack_request.parameters['action']
-          input_encoding = parse_charset(action_pack_request.env['HTTP_CONTENT_TYPE'])
-          protocol_options = { 
-            :soap_action => soap_action,
-            :charset  => input_encoding
-          }
-          decode_request(action_pack_request.raw_post, service_name, protocol_options)
-        end
-
-        def encode_action_pack_request(service_name, public_method_name, raw_body, options={})
-          request = super
-          request.env['HTTP_SOAPACTION'] = '/soap/%s/%s' % [service_name, public_method_name]
-          request
-        end
-
-        def decode_request(raw_request, service_name, protocol_options={})
-          envelope = SOAP::Processor.unmarshal(raw_request, :charset => protocol_options[:charset])
-          unless envelope
-            raise ProtocolError, "Failed to parse SOAP request message"
-          end
-          request = envelope.body.request
-          method_name = request.elename.name
-          params = request.collect{ |k, v| marshaler.soap_to_ruby(request[k]) }
-          Request.new(self, method_name, params, service_name, nil, nil, protocol_options)
-        end
-
-        def encode_request(method_name, params, param_types)
-          param_types.each{ |type| marshaler.register_type(type) } if param_types
-          qname = XSD::QName.new(marshaler.namespace, method_name)
-          param_def = []
-          if param_types
-            params = param_types.zip(params).map do |type, param|
-              param_def << ['in', type.name, marshaler.lookup_type(type).mapping]
-              [type.name, marshaler.ruby_to_soap(param)]
-            end
-          else
-            params = []
-          end
-          request = SOAP::RPC::SOAPMethodRequest.new(qname, param_def)
-          request.set_param(params)
-          envelope = create_soap_envelope(request)
-          SOAP::Processor.marshal(envelope)
-        end
-
-        def decode_response(raw_response)
-          envelope = SOAP::Processor.unmarshal(raw_response)
-          unless envelope
-            raise ProtocolError, "Failed to parse SOAP request message"
-          end
-          method_name = envelope.body.request.elename.name
-          return_value = envelope.body.response
-          return_value = marshaler.soap_to_ruby(return_value) unless return_value.nil?
-          [method_name, return_value]
-        end
-
-        def encode_response(method_name, return_value, return_type, protocol_options={})
-          if return_type
-            return_binding = marshaler.register_type(return_type)
-            marshaler.annotate_arrays(return_binding, return_value)
-          end
-          qname = XSD::QName.new(marshaler.namespace, method_name)
-          if return_value.nil?
-            response = SOAP::RPC::SOAPMethodResponse.new(qname, nil)
-          else
-            if return_value.is_a?(Exception)
-              detail = SOAP::Mapping::SOAPException.new(return_value)
-              response = SOAP::SOAPFault.new(
-                SOAP::SOAPQName.new('%s:%s' % [SOAP::SOAPNamespaceTag, 'Server']),
-                SOAP::SOAPString.new(return_value.to_s),
-                SOAP::SOAPString.new(self.class.name),
-                marshaler.ruby_to_soap(detail))
-            else
-              if return_type
-                param_def = [['retval', 'return', marshaler.lookup_type(return_type).mapping]]
-                response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
-                response.retval = marshaler.ruby_to_soap(return_value)
-              else
-                response = SOAP::RPC::SOAPMethodResponse.new(qname, nil)
-              end
-            end
-          end
-          envelope = create_soap_envelope(response)
-
-          # FIXME: This is not thread-safe, but StringFactory_ in SOAP4R only
-          #        reads target encoding from the XSD::Charset.encoding variable.
-          #        This is required to ensure $KCODE strings are converted
-          #        correctly to UTF-8 for any values of $KCODE.
-          previous_encoding = XSD::Charset.encoding
-          XSD::Charset.encoding = XSDEncoding
-          response_body = SOAP::Processor.marshal(envelope, :charset => AWSEncoding)
-          XSD::Charset.encoding = previous_encoding
-
-          Response.new(response_body, "text/xml; charset=#{AWSEncoding}", return_value)
-        end
-
-        def protocol_client(api, protocol_name, endpoint_uri, options={})
-          return nil unless protocol_name == :soap
-          ActionWebService::Client::Soap.new(api, endpoint_uri, options)
-        end
-
-        def register_api(api)
-          api.api_methods.each do |name, method|
-            method.expects.each{ |type| marshaler.register_type(type) } if method.expects
-            method.returns.each{ |type| marshaler.register_type(type) } if method.returns
-          end
-        end
-
-        private
-          def has_valid_soap_action?(request)
-            return nil unless request.method == :post
-            soap_action = request.env['HTTP_SOAPACTION']
-            return nil unless soap_action
-            soap_action = soap_action.dup
-            soap_action.gsub!(/^"/, '')
-            soap_action.gsub!(/"$/, '')
-            soap_action.strip!
-            return nil if soap_action.empty?
-            soap_action
-          end
-
-          def create_soap_envelope(body)
-            header = SOAP::SOAPHeader.new
-            body = SOAP::SOAPBody.new(body)
-            SOAP::SOAPEnvelope.new(header, body)
-          end
-
-          def parse_charset(content_type)
-            return AWSEncoding if content_type.nil?
-            if /^text\/xml(?:\s*;\s*charset=([^"]+|"[^"]+"))$/i =~ content_type
-              $1
-            else
-              AWSEncoding
-            end
-          end
-      end
-    end
-  end
-end