actionwebservice 0.6.2 → 0.7.0

data/lib/action_web_service/api/base.rb

@@ -1,135 +0,0 @@
-module ActionWebService # :nodoc:
-  module API # :nodoc:
-    # A web service API class specifies the methods that will be available for
-    # invocation for an API. It also contains metadata such as the method type
-    # signature hints.
-    #
-    # It is not intended to be instantiated.
-    #
-    # It is attached to web service implementation classes like
-    # ActionWebService::Base and ActionController::Base derivatives by using
-    # ClassMethods#web_service_api.
-    class Base
-      # Whether to transform the public API method names into camel-cased names 
-      class_inheritable_option :inflect_names, true
-
-      # Whether to allow ActiveRecord::Base models in <tt>:expects</tt>.
-      # The default is +false+, you should be aware of the security implications
-      # of allowing this, and ensure that you don't allow remote callers to
-      # easily overwrite data they should not have access to.
-      class_inheritable_option :allow_active_record_expects, false
-
-      # If present, the name of a method to call when the remote caller
-      # tried to call a nonexistent method. Semantically equivalent to
-      # +method_missing+.
-      class_inheritable_option :default_api_method
-
-      # Disallow instantiation
-      private_class_method :new, :allocate
-      
-      class << self
-        # API methods have a +name+, which must be the Ruby method name to use when
-        # performing the invocation on the web service object.
-        #
-        # The signatures for the method input parameters and return value can
-        # by specified in +options+.
-        #
-        # A signature is an array of one or more parameter specifiers. 
-        # 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.
-        # * 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
-        #   as an array containing only values of the given type.
-        # * A Hash containing as key the name of the parameter, and as value
-        #   one of the three preceding items
-        # 
-        # If no method input parameter or method return value signatures are given,
-        # the method is assumed to take no parameters and/or return no values of
-        # interest, and any values that are received by the server will be
-        # discarded and ignored.
-        #
-        # Valid options:
-        # [<tt>:expects</tt>]             Signature for the method input parameters
-        # [<tt>:returns</tt>]             Signature for the method return value
-        # [<tt>:expects_and_returns</tt>] Signature for both input parameters and return value
-        def api_method(name, options={})
-          validate_options([:expects, :returns, :expects_and_returns], options.keys)
-          if options[:expects_and_returns]
-            expects = options[:expects_and_returns]
-            returns = options[:expects_and_returns]
-          else
-            expects = options[:expects]
-            returns = options[:returns]
-          end
-          expects = canonical_signature(expects)
-          returns = canonical_signature(returns)
-          if expects
-            expects.each do |param|
-              klass = WS::BaseTypes.canonical_param_type_class(param)
-              klass = klass[0] if klass.is_a?(Array)
-              if klass.ancestors.include?(ActiveRecord::Base) && !allow_active_record_expects
-                raise(ActionWebServiceError, "ActiveRecord model classes not allowed in :expects")
-              end
-            end
-          end
-          name = name.to_sym
-          public_name = public_api_method_name(name)
-          info = { :expects => expects, :returns => returns }
-          write_inheritable_hash("api_methods", name => info)
-          write_inheritable_hash("api_public_method_names", public_name => name)
-        end
-
-        # Whether the given method name is a service method on this API
-        def has_api_method?(name)
-          api_methods.has_key?(name)
-        end
-  
-        # Whether the given public method name has a corresponding service method
-        # on this API
-        def has_public_api_method?(public_name)
-          api_public_method_names.has_key?(public_name)
-        end
-  
-        # The corresponding public method name for the given service method name
-        def public_api_method_name(name)
-          if inflect_names
-            name.to_s.camelize
-          else
-            name.to_s
-          end
-        end
-  
-        # The corresponding service method name for the given public method name
-        def api_method_name(public_name)
-          api_public_method_names[public_name]
-        end
-  
-        # A Hash containing all service methods on this API, and their
-        # associated metadata.
-        def api_methods
-          read_inheritable_attribute("api_methods") || {}
-        end
-  
-        private
-          def api_public_method_names
-            read_inheritable_attribute("api_public_method_names") || {}
-          end
-  
-          def validate_options(valid_option_keys, supplied_option_keys)
-            unknown_option_keys = supplied_option_keys - valid_option_keys
-            unless unknown_option_keys.empty?
-              raise(ActionWebServiceError, "Unknown options: #{unknown_option_keys}")
-            end
-          end
-
-          def canonical_signature(signature)
-            return nil if signature.nil?
-            signature.map{|spec| WS::BaseTypes.canonical_param_type_spec(spec)}
-          end
-      end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws.rb

@@ -1,4 +0,0 @@
-require 'ws/common'
-require 'ws/types'
-require 'ws/marshaling'
-require 'ws/encoding'

data/lib/action_web_service/vendor/ws/common.rb

@@ -1,8 +0,0 @@
-module WS
-  class WSError < StandardError
-  end
-
-  def self.derived_from?(ancestor, child)
-    child.ancestors.include?(ancestor)
-  end
-end

data/lib/action_web_service/vendor/ws/encoding.rb

@@ -1,3 +0,0 @@
-require 'ws/encoding/abstract'
-require 'ws/encoding/soap_rpc_encoding'
-require 'ws/encoding/xmlrpc_encoding'

data/lib/action_web_service/vendor/ws/encoding/abstract.rb

@@ -1,26 +0,0 @@
-module WS
-  module Encoding
-    # Encoders operate on _foreign_ objects. That is, Ruby object
-    # instances that are the _marshaling format specific_ representation
-    # of objects. In other words, objects that have not yet been marshaled, but
-    # are in protocol-specific form (such as an AST or DOM element), and not
-    # native Ruby form.
-    class AbstractEncoding
-      def encode_rpc_call(method_name, params)
-        raise NotImplementedError
-      end
-
-      def decode_rpc_call(obj)
-        raise NotImplementedError
-      end
-
-      def encode_rpc_response(method_name, return_value)
-        raise NotImplementedError
-      end
-
-      def decode_rpc_response(obj)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws/encoding/soap_rpc_encoding.rb

@@ -1,90 +0,0 @@
-require 'soap/processor'
-require 'soap/mapping'
-require 'soap/rpc/element'
-
-module WS
-  module Encoding
-    class SoapRpcError < WSError
-    end
-
-    class SoapRpcEncoding < AbstractEncoding
-      attr_accessor :method_namespace
-
-      def initialize(method_namespace='')
-        @method_namespace = method_namespace
-      end
-
-      def encode_rpc_call(method_name, foreign_params)
-        qname = create_method_qname(method_name)
-        param_def = []
-        params = foreign_params.map do |p|
-          param_def << ['in', p.param.info.name, p.param.info.data.mapping]
-          [p.param.info.name, p.soap_object]
-        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_rpc_call(obj)
-        envelope = SOAP::Processor.unmarshal(obj)
-        unless envelope
-          raise(SoapRpcError, "Malformed SOAP request")
-        end
-        request = envelope.body.request
-        method_name = request.elename.name
-        params = request.collect do |key, value|
-          info = ParamInfo.new(key, nil, nil)
-          param = Param.new(nil, info)
-          Marshaling::SoapForeignObject.new(param, request[key])
-        end
-        [method_name, params]
-      end
-
-      def encode_rpc_response(method_name, return_value)
-        response = nil
-        qname = create_method_qname(method_name)
-        if return_value.nil?
-          response = SOAP::RPC::SOAPMethodResponse.new(qname, nil)
-        else
-          param = return_value.param
-          soap_object = return_value.soap_object
-          param_def = [['retval', 'return', param.info.data.mapping]]
-          if soap_object.is_a?(SOAP::SOAPFault)
-            response = soap_object
-          else
-            response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
-            response.retval = soap_object
-          end
-        end
-        envelope = create_soap_envelope(response)
-        SOAP::Processor.marshal(envelope)
-      end
-
-      def decode_rpc_response(obj)
-        envelope = SOAP::Processor.unmarshal(obj)
-        unless envelope
-          raise(SoapRpcError, "Malformed SOAP response")
-        end
-        method_name = envelope.body.request.elename.name
-        return_value = envelope.body.response
-        info = ParamInfo.new('return', nil, nil)
-        param = Param.new(nil, info)
-        return_value = Marshaling::SoapForeignObject.new(param, return_value)
-        [method_name, return_value]
-      end
-
-      private
-        def create_soap_envelope(body)
-          header = SOAP::SOAPHeader.new
-          body = SOAP::SOAPBody.new(body)
-          SOAP::SOAPEnvelope.new(header, body)
-        end
-
-        def create_method_qname(method_name)
-          XSD::QName.new(@method_namespace, method_name)
-        end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws/encoding/xmlrpc_encoding.rb

@@ -1,53 +0,0 @@
-require 'xmlrpc/marshal'
-
-module WS
-  module Encoding
-    class XmlRpcError < WSError
-    end
-
-    class XmlRpcEncoding < AbstractEncoding
-      def encode_rpc_call(method_name, params)
-        XMLRPC::Marshal.dump_call(method_name, *params)
-      end
-
-      def decode_rpc_call(obj)
-        method_name, params = XMLRPC::Marshal.load_call(obj) rescue nil
-        unless method_name && params
-          raise(XmlRpcError, "Malformed XML-RPC request")
-        end
-        i = 0
-        params = params.map do |value|
-          param = XmlRpcDecodedParam.new("param#{i}", value)
-          i += 1
-          param
-        end
-        [method_name, params]
-      end
-
-      def encode_rpc_response(method_name, return_value)
-        if return_value.nil?
-          XMLRPC::Marshal.dump_response(true)
-        else
-          XMLRPC::Marshal.dump_response(return_value)
-        end
-      end
-
-      def decode_rpc_response(obj)
-        return_value = XMLRPC::Marshal.load_response(obj) rescue nil
-        if return_value.nil? 
-          raise(XmlRpcError, "Malformed XML-RPC response")
-        end
-        [nil, XmlRpcDecodedParam.new('return', return_value)]
-      end
-    end
-
-    class XmlRpcDecodedParam
-      attr :param
-
-      def initialize(name, value)
-        info = ParamInfo.new(name, value.class)
-        @param = Param.new(value, info)
-      end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws/marshaling.rb

@@ -1,3 +0,0 @@
-require 'ws/marshaling/abstract'
-require 'ws/marshaling/soap_marshaling'
-require 'ws/marshaling/xmlrpc_marshaling'

data/lib/action_web_service/vendor/ws/marshaling/abstract.rb

@@ -1,17 +0,0 @@
-module WS
-  module Marshaling
-    class AbstractMarshaler
-      def marshal(param)
-        raise NotImplementedError
-      end
-
-      def unmarshal(param)
-        raise NotImplementedError
-      end
-
-      def register_type(type)
-        nil
-      end
-    end
-  end
-end

data/lib/action_web_service/vendor/ws/marshaling/soap_marshaling.rb

@@ -1,277 +0,0 @@
-require 'soap/mapping'
-require 'xsd/ns'
-
-module WS
-  module Marshaling
-    SoapEncodingNS = 'http://schemas.xmlsoap.org/soap/encoding/'
-
-    class SoapError < WSError
-    end
-
-    class SoapMarshaler < AbstractMarshaler
-      attr :registry
-      attr_accessor :type_namespace
-
-      def initialize(type_namespace='')
-        @type_namespace = type_namespace
-        @registry = SOAP::Mapping::Registry.new
-        @spec2binding = {}
-      end
-
-      def marshal(param)
-        annotate_arrays(param.info.data, param.value)
-        if param.value.is_a?(Exception)
-          detail = SOAP::Mapping::SOAPException.new(param.value)
-          soap_obj = SOAP::SOAPFault.new(
-            SOAP::SOAPQName.new('%s:%s' % [SOAP::SOAPNamespaceTag, 'Server']),
-            SOAP::SOAPString.new(param.value.to_s),
-            SOAP::SOAPString.new(self.class.name),
-            SOAP::Mapping.obj2soap(detail))
-        else
-          soap_obj = SOAP::Mapping.obj2soap(param.value, @registry)
-        end
-        SoapForeignObject.new(param, soap_obj)
-      end
-
-      def unmarshal(obj)
-        param = obj.param
-        soap_object = obj.soap_object
-        soap_type = soap_object ? soap_object.type : nil
-        value = soap_object ? SOAP::Mapping.soap2obj(soap_object, @registry) : nil
-        param.value = value
-        param.info.type = value.class
-        mapping = @registry.find_mapped_soap_class(param.info.type) rescue nil
-        if soap_type && soap_type.name == 'Array' && soap_type.namespace == SoapEncodingNS
-          param.info.data = SoapBinding.new(self, soap_object.arytype, Array, mapping)
-        else
-          param.info.data = SoapBinding.new(self, soap_type, value.class, mapping)
-        end
-        param
-      end
-
-      def register_type(spec)
-        if @spec2binding.has_key?(spec)
-          return @spec2binding[spec]
-        end
-
-        klass = BaseTypes.canonical_param_type_class(spec)
-        if klass.is_a?(Array)
-          type_class = klass[0]
-        else
-          type_class = klass
-        end
-
-        type_binding = nil
-        if (mapping = @registry.find_mapped_soap_class(type_class) rescue nil)
-          qname = mapping[2] ? mapping[2][:type] : nil
-          qname ||= soap_base_type_name(mapping[0])
-          type_binding = SoapBinding.new(self, qname, type_class, mapping)
-        else
-          qname = XSD::QName.new(@type_namespace, soap_type_name(type_class.name))
-          @registry.add(type_class,
-                        SOAP::SOAPStruct,
-                        typed_struct_factory(type_class),
-                        { :type => qname })
-          mapping = @registry.find_mapped_soap_class(type_class)
-          type_binding = SoapBinding.new(self, qname, type_class, mapping)
-        end
-        
-        array_binding = nil
-        if klass.is_a?(Array)
-          array_mapping = @registry.find_mapped_soap_class(Array) rescue nil
-          if (array_mapping && !array_mapping[1].is_a?(SoapTypedArrayFactory)) || array_mapping.nil?
-            @registry.set(Array,
-                          SOAP::SOAPArray,
-                          SoapTypedArrayFactory.new)
-            array_mapping = @registry.find_mapped_soap_class(Array)
-          end
-          qname = XSD::QName.new(@type_namespace, soap_type_name(type_class.name) + 'Array')
-          array_binding = SoapBinding.new(self, qname, Array, array_mapping, type_binding)
-        end
-
-        @spec2binding[spec] = array_binding ? array_binding : type_binding
-        @spec2binding[spec]
-      end
-
-      protected
-        def annotate_arrays(binding, value)
-          if binding.is_typed_array?
-            mark_typed_array(value, binding.element_binding.qname)
-            if binding.element_binding.is_custom_type?
-              value.each do |element|
-                annotate_arrays(register_type(element.class), element)
-              end
-            end
-          elsif binding.is_typed_struct?
-            if binding.type_class.respond_to?(:members)
-              binding.type_class.members.each do |name, spec|
-                member_binding = register_type(spec)
-                member_value = value.send(name)
-                if member_binding.is_custom_type?
-                  annotate_arrays(member_binding, member_value)
-                end
-              end
-            end
-          end
-        end
-
-        def mark_typed_array(array, qname)
-          (class << array; self; end).class_eval do 
-            define_method(:arytype) do
-              qname
-            end
-          end
-        end
-
-        def typed_struct_factory(type_class)
-          if Object.const_defined?('ActiveRecord')
-            if WS.derived_from?(ActiveRecord::Base, type_class)
-              qname =  XSD::QName.new(@type_namespace, soap_type_name(type_class.name))
-              type_class.instance_variable_set('@qname', qname)
-              return SoapActiveRecordStructFactory.new
-            end
-          end
-          SOAP::Mapping::Registry::TypedStructFactory
-        end
-
-        def soap_type_name(type_name)
-          type_name.gsub(/::/, '..')
-        end
-
-        def soap_base_type_name(type)
-          xsd_type = type.ancestors.find{|c| c.const_defined? 'Type'}
-          xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
-        end
-    end
-
-    class SoapForeignObject
-      attr_accessor :param
-      attr_accessor :soap_object
-
-      def initialize(param, soap_object)
-        @param = param
-        @soap_object = soap_object
-      end
-    end
-
-    class SoapBinding
-      attr :qname
-      attr :type_class
-      attr :mapping
-      attr :element_binding
-
-      def initialize(marshaler, qname, type_class, mapping, element_binding=nil)
-        @marshaler = marshaler
-        @qname = qname
-        @type_class = type_class
-        @mapping = mapping
-        @element_binding = element_binding
-      end
-
-      def is_custom_type?
-        is_typed_array? || is_typed_struct?
-      end
-
-      def is_typed_array?
-        @mapping[1].is_a?(WS::Marshaling::SoapTypedArrayFactory)
-      end
-
-      def is_typed_struct?
-        @mapping[1] == SOAP::Mapping::Registry::TypedStructFactory || \
-        @mapping[1].is_a?(WS::Marshaling::SoapActiveRecordStructFactory)
-      end
-
-      def each_member(&block)
-        if is_typed_struct?
-          if @mapping[1] == SOAP::Mapping::Registry::TypedStructFactory
-            if @type_class.respond_to?(:members)
-              @type_class.members.each do |name, spec|
-                yield name, spec
-              end
-            end
-          elsif @mapping[1].is_a?(WS::Marshaling::SoapActiveRecordStructFactory)
-            @type_class.columns.each do |column|
-              yield column.name, column.klass
-            end
-          end
-        end
-      end
-
-      def type_name
-        is_custom_type? ? @qname.name : nil
-      end
-
-      def qualified_type_name(ns=nil)
-        if is_custom_type?
-          "#{ns ? ns : @qname.namespace}:#{@qname.name}"
-        else
-          ns = XSD::NS.new
-          ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
-          xsd_klass = mapping[0].ancestors.find{|c| c.const_defined?('Type')}
-          return ns.name(XSD::AnyTypeName) unless xsd_klass
-          ns.name(xsd_klass.const_get('Type'))
-        end
-      end
-    end
-
-    class SoapActiveRecordStructFactory < SOAP::Mapping::Factory
-      def obj2soap(soap_class, obj, info, map)
-        unless obj.is_a?(ActiveRecord::Base)
-          return nil
-        end
-        soap_obj = soap_class.new(obj.class.instance_variable_get('@qname'))
-        obj.class.columns.each do |column|
-          key = column.name.to_s
-          value = obj.send(key)
-          soap_obj[key] = SOAP::Mapping._obj2soap(value, map)
-        end
-        soap_obj
-      end
-
-      def soap2obj(obj_class, node, info, map)
-        unless node.type == obj_class.instance_variable_get('@qname')
-          return false
-        end
-        obj = obj_class.new
-        node.each do |key, value|
-          obj[key] = value.data
-        end
-        obj.instance_variable_set('@new_record', false)
-        return true, obj
-      end
-    end
-
-    class SoapTypedArrayFactory < SOAP::Mapping::Factory
-      def obj2soap(soap_class, obj, info, map)
-        unless obj.respond_to?(:arytype)
-          return nil
-        end
-        soap_obj = soap_class.new(SOAP::ValueArrayName, 1, obj.arytype)
-        mark_marshalled_obj(obj, soap_obj)
-        obj.each do |item|
-          child = SOAP::Mapping._obj2soap(item, map)
-          soap_obj.add(child)
-        end
-        soap_obj
-      end
-    
-      def soap2obj(obj_class, node, info, map)
-        return false
-      end
-    end
-
-    module ActiveRecordSoapMarshallable
-      def allocate
-        obj = super
-        attrs = {}
-        self.columns.each{|c| attrs[c.name.to_s] = c.default}
-        obj.instance_variable_set('@attributes', attrs)
-        obj
-      end
-    end
-
-    if Object.const_defined?('ActiveRecord')
-      ActiveRecord::Base.extend(ActiveRecordSoapMarshallable)
-    end
-  end
-end