module ActionWebService # :nodoc:
module Protocol # :nodoc:
CheckedMessage = :checked
UncheckedMessage = :unchecked
class ProtocolError < ActionWebService::ActionWebServiceError # :nodoc:
end
class AbstractProtocol # :nodoc:
attr :container_class
def initialize(container_class)
@container_class = container_class
end
def unmarshal_request(protocol_request)
raise NotImplementedError
end
def marshal_response(protocol_request, return_value)
raise NotImplementedError
end
def marshal_exception(exception)
raise NotImplementedError
end
def self.create_protocol_request(container_class, action_pack_request)
nil
end
def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
nil
end
end
class AbstractProtocolMessage # :nodoc:
attr_accessor :signature
attr_accessor :return_signature
attr_accessor :type
attr :options
def initialize(options={})
@signature = @return_signature = nil
@options = options
@type = @options[:type] || CheckedMessage
end
def signature=(value)
return if value.nil?
@signature = []
value.each do |klass|
if klass.is_a?(Hash)
@signature << klass.values.shift
else
@signature << klass
end
end
@signature
end
def checked?
@type == CheckedMessage
end
def check_parameter_types(values, signature)
return unless checked? && signature
unless signature.length == values.length
raise(ProtocolError, "Signature and parameter lengths mismatch")
end
(1..signature.length).each do |i|
check_compatibility(signature[i-1], values[i-1].class)
end
end
def check_compatibility(expected_class, received_class)
return if \
(expected_class == TrueClass or expected_class == FalseClass) and \
(received_class == TrueClass or received_class == FalseClass)
unless received_class.ancestors.include?(expected_class) or \
expected_class.ancestors.include?(received_class)
raise(ProtocolError, "value of type #{received_class.name} is not " +
"compatible with expected type #{expected_class.name}")
end
end
end
class ProtocolRequest < AbstractProtocolMessage # :nodoc:
attr :protocol
attr :raw_body
attr_accessor :web_service_name
attr_accessor :public_method_name
attr_accessor :content_type
def initialize(protocol, raw_body, web_service_name, public_method_name, content_type, options={})
super(options)
@protocol = protocol
@raw_body = raw_body
@web_service_name = web_service_name
@public_method_name = public_method_name
@content_type = content_type
end
def unmarshal
@protocol.unmarshal_request(self)
end
def marshal(return_value)
@protocol.marshal_response(self, return_value)
end
end
class ProtocolResponse < AbstractProtocolMessage # :nodoc:
attr :protocol
attr :raw_body
attr_accessor :content_type
def initialize(protocol, raw_body, content_type, options={})
super(options)
@protocol = protocol
@raw_body = raw_body
@content_type = content_type
end
end
end
end
