actionwebservice 0.6.2 → 0.7.0

data/lib/action_web_service/protocol/xmlrpc_protocol.rb

@@ -1,3 +1,9 @@
+require 'xmlrpc/marshal'
+
+class XMLRPC::FaultException
+  alias :message :faultString
+end
+
 module ActionWebService # :nodoc:
   module Protocol # :nodoc:
     module XmlRpc # :nodoc:
@@ -5,43 +11,69 @@ module ActionWebService # :nodoc:
         base.register_protocol(XmlRpcProtocol)
       end
       
-      class XmlRpcProtocol # :nodoc:
-        attr :marshaler
-
-        def initialize
-          @encoder = WS::Encoding::XmlRpcEncoding.new
-          @marshaler = WS::Marshaling::XmlRpcMarshaler.new
+      class XmlRpcProtocol < AbstractProtocol # :nodoc:
+        def decode_action_pack_request(action_pack_request)
+          service_name = action_pack_request.parameters['action']
+          decode_request(action_pack_request.raw_post, service_name)
         end
 
-        def unmarshal_request(ap_request)
-          method_name, params = @encoder.decode_rpc_call(ap_request.raw_post)
-          params = params.map{|x| @marshaler.unmarshal(x)}
-          service_name = ap_request.parameters['action']
+        def decode_request(raw_request, service_name)
+          method_name, params = XMLRPC::Marshal.load_call(raw_request)
           Request.new(self, method_name, params, service_name)
-        rescue
-          nil
         end
 
-        def marshal_response(method_name, return_value, signature_type)
-          if !return_value.nil? && signature_type
-            type_binding = @marshaler.register_type(signature_type)
-            info = WS::ParamInfo.create(signature_type, type_binding, 0)
-            return_value = @marshaler.marshal(WS::Param.new(return_value, info))
-          else
-            return_value = nil
+        def encode_request(method_name, params, param_types)
+          if param_types
+            params = params.dup
+            param_types.each_with_index{ |type, i| params[i] = value_to_xmlrpc_wire_format(params[i], type) }
           end
-          body = @encoder.encode_rpc_response(method_name, return_value)
-          Response.new(body, 'text/xml')
+          XMLRPC::Marshal.dump_call(method_name, *params)
+        end
+
+        def decode_response(raw_response)
+          [nil, XMLRPC::Marshal.load_response(raw_response)]
         end
 
-        def register_signature_type(spec)
-          nil
+        def encode_response(method_name, return_value, return_type)
+          return_value = true if return_value.nil?
+          if return_type
+            return_value = value_to_xmlrpc_wire_format(return_value, return_type)
+          end
+          raw_response = XMLRPC::Marshal.dump_response(return_value)
+          Response.new(raw_response, 'text/xml', return_value)
         end
 
-        def protocol_client(api, protocol_name, endpoint_uri, options)
+        def protocol_client(api, protocol_name, endpoint_uri, options={})
           return nil unless protocol_name == :xmlrpc
           ActionWebService::Client::XmlRpc.new(api, endpoint_uri, options)
         end
+
+        def value_to_xmlrpc_wire_format(value, value_type)
+          if value_type.array?
+            value.map{ |val| value_to_xmlrpc_wire_format(val, value_type.element_type) }
+          else
+            if value.is_a?(ActionWebService::Struct)
+              struct = {}
+              value.class.members.each do |name, type|
+                member_value = value[name]
+                next if member_value.nil?
+                struct[name.to_s] = value_to_xmlrpc_wire_format(member_value, type)
+              end
+              struct
+            elsif value.is_a?(ActiveRecord::Base)
+              struct = {}
+              value.attributes.each do |key, member_value|
+                next if member_value.nil?
+                struct[key.to_s] = member_value
+              end
+              struct
+            elsif value.is_a?(Exception) && !value.is_a?(XMLRPC::FaultException)
+              XMLRPC::FaultException.new(2, value.message)
+            else
+              value
+            end
+          end
+        end
       end
     end
   end

data/lib/action_web_service/scaffolding.rb

@@ -0,0 +1,237 @@
+require 'ostruct'
+require 'uri'
+require 'benchmark'
+require 'pathname'
+
+module ActionWebService
+  module Scaffolding # :nodoc:
+    class ScaffoldingError < ActionWebServiceError # :nodoc:
+    end
+
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    # Web service invocation scaffolding provides a way to quickly invoke web service methods in a controller. The
+    # generated scaffold actions have default views to let you enter the method parameters and view the
+    # results.
+    #
+    # Example:
+    #
+    #   class ApiController < ActionController
+    #     web_service_scaffold :invoke
+    #   end
+    #
+    # This example generates an +invoke+ action in the +ApiController+ that you can navigate to from
+    # your browser, select the API method, enter its parameters, and perform the invocation.
+    #
+    # If you want to customize the default views, create the following views in "app/views":
+    #
+    # * <tt>action_name/methods.rhtml</tt>
+    # * <tt>action_name/parameters.rhtml</tt>
+    # * <tt>action_name/result.rhtml</tt>
+    # * <tt>action_name/layout.rhtml</tt>
+    #
+    # Where <tt>action_name</tt> is the name of the action you gave to ClassMethods#web_service_scaffold.
+    #
+    # You can use the default views in <tt>RAILS_DIR/lib/action_web_service/templates/scaffolds</tt> as
+    # a guide.
+    module ClassMethods
+      # Generates web service invocation scaffolding for the current controller. The given action name
+      # can then be used as the entry point for invoking API methods from a web browser.
+      def web_service_scaffold(action_name)
+        add_template_helper(Helpers)
+        module_eval <<-END, __FILE__, __LINE__
+          def #{action_name}
+            if @request.method == :get
+              setup_invocation_assigns
+              render_invocation_scaffold 'methods'
+            end
+          end
+
+          def #{action_name}_method_params
+            if @request.method == :get
+              setup_invocation_assigns
+              render_invocation_scaffold 'parameters'
+            end
+          end
+
+          def #{action_name}_submit
+            if @request.method == :post
+              setup_invocation_assigns
+              protocol_name = @params['protocol'] ? @params['protocol'].to_sym : :soap
+              case protocol_name
+              when :soap
+                @protocol = Protocol::Soap::SoapProtocol.new
+              when :xmlrpc
+                @protocol = Protocol::XmlRpc::XmlRpcProtocol.new
+              end
+              @invocation_cgi = @request.respond_to?(:cgi) ? @request.cgi : nil
+              bm = Benchmark.measure do
+                @protocol.register_api(@scaffold_service.api)
+                params = @params['method_params'] ? @params['method_params'].dup : nil
+                params = @scaffold_method.cast_expects(params)
+                method_name = public_method_name(@scaffold_service.name, @scaffold_method.public_name)
+                @method_request_xml = @protocol.encode_request(method_name, params, @scaffold_method.expects)
+                new_request = @protocol.encode_action_pack_request(@scaffold_service.name, @scaffold_method.public_name, @method_request_xml)
+                prepare_request(new_request, @scaffold_service.name, @scaffold_method.public_name)
+                @request = new_request
+                dispatch_web_service_request
+                @method_response_xml = @response.body
+                method_name, obj = @protocol.decode_response(@method_response_xml)
+                return if handle_invocation_exception(obj)
+                @method_return_value = @scaffold_method.cast_returns(obj)
+              end
+              @method_elapsed = bm.real
+              add_instance_variables_to_assigns
+              reset_invocation_response
+              render_invocation_scaffold 'result'
+            end
+          end
+
+          private
+            def setup_invocation_assigns
+              @scaffold_class = self.class
+              @scaffold_action_name = "#{action_name}"
+              @scaffold_container = WebServiceModel::Container.new(self)
+              if @params['service'] && @params['method']
+                @scaffold_service = @scaffold_container.services.find{ |x| x.name == @params['service'] }
+                @scaffold_method = @scaffold_service.api_methods[@params['method']]
+              end
+              add_instance_variables_to_assigns
+            end
+
+            def render_invocation_scaffold(action)
+              customized_template = "\#{self.class.controller_path}/#{action_name}/\#{action}"
+              default_template = scaffold_path(action)
+              @content_for_layout = template_exists?(customized_template) ? @template.render_file(customized_template) : @template.render_file(default_template, false)
+              self.active_layout ? render_file(self.active_layout, "200 OK", true) : render_file(scaffold_path("layout"))
+            end
+
+            def scaffold_path(template_name)
+              Pathname.new(File.dirname(__FILE__) + "/templates/scaffolds/" + template_name + ".rhtml").realpath.to_s
+            end
+
+            def reset_invocation_response
+              template = @response.template
+              if @invocation_cgi
+                @response = ::ActionController::CgiResponse.new(@invocation_cgi)
+              else
+                @response = ::ActionController::TestResponse.new
+              end
+              @response.template = template
+              @performed_render = false
+            end
+
+            def public_method_name(service_name, method_name)
+              if web_service_dispatching_mode == :layered && @protocol.is_a?(ActionWebService::Protocol::XmlRpc::XmlRpcProtocol)
+                service_name + '.' + method_name
+              else
+                method_name
+              end
+            end
+
+            def prepare_request(request, service_name, method_name)
+              request.parameters.update(@request.parameters)
+              if web_service_dispatching_mode == :layered && @protocol.is_a?(ActionWebService::Protocol::Soap::SoapProtocol)
+                request.env['HTTP_SOAPACTION'] = "/\#{controller_name()}/\#{service_name}/\#{method_name}"
+              end
+            end
+
+            def handle_invocation_exception(obj)
+              exception = nil
+              if obj.respond_to?(:detail) && obj.detail.respond_to?(:cause) && obj.detail.cause.is_a?(Exception)
+                exception = obj.detail.cause
+              elsif obj.is_a?(XMLRPC::FaultException)
+                exception = obj
+              end
+              return unless exception
+              reset_invocation_response
+              rescue_action(exception)
+              true
+            end
+        END
+      end
+    end
+
+    module Helpers # :nodoc:
+      def method_parameter_input_fields(method, type)
+        name = type.name.to_s
+        type_name = type.type
+        unless type_name.is_a?(Symbol)
+          raise "Parameter #{name}: Structured/array types not supported in scaffolding input fields yet"
+        end
+        field_name = "method_params[]"
+        case type_name
+        when :int
+          text_field_tag field_name
+        when :string
+          text_field_tag field_name
+        when :bool
+          radio_button_tag field_name, "True"
+          radio_button_tag field_name, "False"
+        when :float
+          text_field_tag field_name
+        when :time
+          select_datetime Time.now, 'name' => field_name
+        when :date
+          select_date Date.today, 'name' => field_name
+        end
+      end
+
+      def service_method_list(service)
+        action = @scaffold_action_name + '_method_params'
+        methods = service.api_methods_full.map do |desc, name|
+          content_tag("li", link_to(desc, :action => action, :service => service.name, :method => name))
+        end
+        content_tag("ul", methods.join("\n"))
+      end
+    end
+
+    module WebServiceModel # :nodoc:
+      class Container # :nodoc:
+        attr :services
+
+        def initialize(real_container)
+          @real_container = real_container
+          @services = []
+          if @real_container.class.web_service_dispatching_mode == :direct
+            @services << Service.new(@real_container.controller_name, @real_container)
+          else
+            @real_container.class.web_services.each do |name, obj|
+              @services << Service.new(name, @real_container.instance_eval{ web_service_object(name) })
+            end
+          end
+        end
+      end
+
+      class Service # :nodoc:
+        attr :name
+        attr :object
+        attr :api
+        attr :api_methods
+        attr :api_methods_full
+
+        def initialize(name, real_service)
+          @name = name.to_s
+          @object = real_service
+          @api = @object.class.web_service_api
+          if @api.nil?
+            raise ScaffoldingError, "No web service API attached to #{object.class}"
+          end
+          @api_methods = {}
+          @api_methods_full = []
+          @api.api_methods.each do |name, method|
+            @api_methods[method.public_name.to_s] = method
+            @api_methods_full << [method.to_s, method.public_name.to_s]
+          end
+        end
+
+        def to_s
+          self.name.camelize
+        end
+      end
+    end
+  end
+end

data/lib/action_web_service/struct.rb

@@ -16,15 +16,15 @@ module ActionWebService
   #   end
   #   person = Person.new(:id => 5, :firstname => 'john', :lastname => 'doe')
   #
-  # Active Record model classes are already implicitly supported for method
-  # return signatures.
+  # Active Record model classes are already implicitly supported in method
+  # signatures.
   class Struct
     
     # If a Hash is given as argument to an ActionWebService::Struct constructor,
     # it can contain initial values for the structure member.
     def initialize(values={})
       if values.is_a?(Hash)
-        values.map{|k,v| send('%s=' % k.to_s, v)}
+        values.map{|k,v| __send__('%s=' % k.to_s, v)}
       end
     end
 
@@ -33,11 +33,20 @@ module ActionWebService
       send(name.to_s)
     end
 
+    # Iterates through each member
+    def each_pair(&block)
+      self.class.members.each do |name, type|
+        yield name, self.__send__(name)
+      end
+    end
+
     class << self
       # Creates a structure member with the specified +name+ and +type+. Generates
       # accessor methods for reading and writing the member value.
       def member(name, type)
-        write_inheritable_hash("struct_members", name => WS::BaseTypes.canonical_param_type_class(type))
+        name = name.to_sym
+        type = ActionWebService::SignatureTypes.canonical_signature_entry({ name => type }, 0)
+        write_inheritable_hash("struct_members", name => type)
         class_eval <<-END
           def #{name}; @#{name}; end
           def #{name}=(value); @#{name} = value; end
@@ -47,6 +56,10 @@ module ActionWebService
       def members # :nodoc:
         read_inheritable_attribute("struct_members") || {}
       end
+
+      def member_type(name) # :nodoc:
+        members[name.to_sym]
+      end
     end
   end
 end

data/lib/action_web_service/support/signature_types.rb

@@ -0,0 +1,194 @@
+module ActionWebService # :nodoc:
+  module SignatureTypes # :nodoc:
+    def canonical_signature(signature)
+      return nil if signature.nil?
+      unless signature.is_a?(Array)
+        raise(ActionWebServiceError, "Expected signature to be an Array")
+      end
+      i = -1
+      signature.map{ |spec| canonical_signature_entry(spec, i += 1) }
+    end
+
+    def canonical_signature_entry(spec, i)
+      orig_spec = spec
+      name = "param#{i}"
+      if spec.is_a?(Hash)
+        name, spec = spec.keys.first, spec.values.first
+      end
+      type = spec
+      if spec.is_a?(Array)
+        ArrayType.new(orig_spec, canonical_signature_entry(spec[0], 0), name)
+      else
+        type = canonical_type(type)
+        if type.is_a?(Symbol)
+          BaseType.new(orig_spec, type, name)
+        else
+          StructuredType.new(orig_spec, type, name)
+        end
+      end
+    end
+
+    def canonical_type(type)
+      type_name = symbol_name(type) || class_to_type_name(type)
+      type = type_name || type
+      return canonical_type_name(type) if type.is_a?(Symbol)
+      type
+    end
+
+    def canonical_type_name(name)
+      name = name.to_sym
+      case name
+        when :int, :integer, :fixnum, :bignum
+          :int
+        when :string, :base64
+          :string
+        when :bool, :boolean
+          :bool
+        when :float, :double
+          :float
+        when :time, :timestamp
+          :time
+        when :datetime
+          :datetime
+        when :date
+          :date
+        else
+          raise(TypeError, "#{name} is not a valid base type")
+      end
+    end
+
+    def canonical_type_class(type)
+      type = canonical_type(type)
+      type.is_a?(Symbol) ? type_name_to_class(type) : type
+    end
+
+    def symbol_name(name)
+      return name.to_sym if name.is_a?(Symbol) || name.is_a?(String)
+      nil
+    end
+
+    def class_to_type_name(klass)
+      klass = klass.class unless klass.is_a?(Class)
+      if derived_from?(Integer, klass) || derived_from?(Fixnum, klass) || derived_from?(Bignum, klass)
+        :int
+      elsif klass == String
+        :string
+      elsif klass == TrueClass || klass == FalseClass
+        :bool
+      elsif derived_from?(Float, klass) || derived_from?(Precision, klass) || derived_from?(Numeric, klass)
+        :float
+      elsif klass == Time
+        :time
+      elsif klass == DateTime
+        :datetime
+      elsif klass == Date
+        :date
+      else
+        nil
+      end
+    end
+
+    def type_name_to_class(name)
+      case canonical_type_name(name)
+      when :int
+        Integer
+      when :string
+        String
+      when :bool
+        TrueClass
+      when :float
+        Float
+      when :time
+        Time
+      when :date
+        Date
+      when :datetime
+        DateTime
+      else
+        nil
+      end
+    end
+
+    def derived_from?(ancestor, child)
+      child.ancestors.include?(ancestor)
+    end
+
+    module_function :type_name_to_class
+    module_function :class_to_type_name
+    module_function :symbol_name
+    module_function :canonical_type_class
+    module_function :canonical_type_name
+    module_function :canonical_type
+    module_function :canonical_signature_entry
+    module_function :canonical_signature
+    module_function :derived_from?
+  end
+
+  class BaseType # :nodoc:
+    include SignatureTypes
+
+    attr :spec
+    attr :type
+    attr :type_class
+    attr :name
+
+    def initialize(spec, type, name)
+      @spec = spec
+      @type = canonical_type(type)
+      @type_class = canonical_type_class(@type)
+      @name = name
+    end
+
+    def custom?
+      false
+    end
+
+    def array?
+      false
+    end
+
+    def structured?
+      false
+    end
+  end
+
+  class ArrayType < BaseType # :nodoc:
+    attr :element_type
+
+    def initialize(spec, element_type, name)
+      super(spec, Array, name)
+      @element_type = element_type
+    end
+
+    def custom?
+      true
+    end
+
+    def array?
+      true
+    end
+  end
+
+  class StructuredType < BaseType # :nodoc:
+    def each_member
+      if @type_class.respond_to?(:members)
+        @type_class.members.each do |name, type|
+          yield name, type
+        end
+      elsif @type_class.respond_to?(:columns)
+        i = -1
+        @type_class.columns.each do |column|
+          yield column.name, canonical_signature_entry(column.klass, i += 1)
+        end
+      end
+    end
+
+    def custom?
+      true
+    end
+
+    def structured?
+      true
+    end
+  end
+end