appcelerator 2.0.1.1 → 2.0.2

data/appcelerator/templates/test_service.rb

@@ -3,9 +3,9 @@ class TestService < Appcelerator::Service
   
   Service 'app.test.message.request', :testMessage, 'app.test.message.response'
   
-  def testMessage(request,message)
-      p "received message: #{message.inspect}"
-      msg = message["message"]
+  def testMessage
+      p "received message: #{params.inspect}"
+      msg = params["message"]
       {"message"=>"I received from you: #{msg}","success"=>true}
   end
   

data/appcelerator/templates/upload_controller.rb

@@ -0,0 +1,55 @@
+
+class UploadController < ApplicationController
+
+  def get_extension(mimetype)
+    case mimetype
+      when 'image/png'
+        return 'png'
+      when 'image/gif'
+        return 'gif'
+      when 'image/jpeg'
+        return 'jpg'
+    end
+  end
+  
+  def make_temp_file(value)
+    extension = get_extension value.content_type.strip || ''
+    uniquename = MD5.new(Time.now.to_s).hexdigest.slice(0,8).gsub(/[^\w\.\-]/,'_') 
+    FileUtils.mkdir_p("#{FileUtils.pwd}/tmp/uploads")
+    f = File.new("#{FileUtils.pwd}/tmp/uploads/#{uniquename}.#{extension}", 'wb')
+    f.write value.read
+    f.close
+    f
+  end
+  
+  def index
+    msg = {}
+    params.each do |key, value|
+      case value.class.to_s
+        when 'String'
+          msg[key] = value
+        when 'StringIO'
+          msg[key] = make_temp_file value
+        when 'Tempfile'
+          msg[key] = make_temp_file value
+      end
+    end
+
+    cb = params['callback']
+    
+    if cb
+      if cb =~ /^(r:|remote:|l:|local:)/
+        @callback = "window.parent.$MQ('#{cb}');"
+      else
+        @callback = cb
+      end
+    else
+      @callback = ''
+    end
+
+    request_id = Time.now
+    message_type = params['type']
+    Appcelerator::Dispatcher.dispatch_message(request, response, session, message_type, msg, request_id)
+
+  end
+end

data/bin/appcelerator

@@ -1,36 +1,57 @@
-#!/usr/bin/env ruby
-
-freeze   = ARGV.any? { |option| %w(--freeze -f).include?(option) }
-app_path = ARGV.first
-
-require 'rubygems'
-gem 'rails', '>= 1.2.3'
-
-# find the path to RAILS
-rails_gem = Gem.cache.search('rails').last
-RAILS = rails_gem.full_gem_path
-
-require RAILS + '/lib/ruby_version_check'
-Signal.trap("INT") { puts; exit }
-
-require RAILS + '/lib/rails/version'
-if %w(--version -v).include? ARGV.first
-  puts "Rails #{Rails::VERSION::STRING}"
-  exit(0)
+require 'pathname'
+require 'erb'
+require 'md5'
+require 'socket'
+require 'fileutils'
+
+args = ''
+ARGV.each do |arg|
+  args = args + "#{arg} "
 end
 
+app_path = ARGV.last
+system('rails ' + args + ' >> rails.log')
+FileUtils.rm_r 'rails.log'
+p = Pathname.new(app_path)
 
-require RAILS + '/lib/rails_generator'
-require 'rails_generator/scripts/generate'
+secret_auth_key = Digest::MD5.hexdigest(Time.new.to_s + self.inspect + IPSocket.getaddress(Socket::gethostname).to_s)   
 
-Rails::Generator::Base.use_application_sources!
+# 
+# remove rails files
+#
+FileUtils.rm_r "#{p}/public/javascripts"
 
-path = File.dirname(__FILE__) + '/../'
-
-Rails::Generator::Base.sources << Rails::Generator::PathSource.new('', path)
-
-# execute the appcelerator generator
-Rails::Generator::Scripts::Generate.new.run(ARGV, {:generator => 'appcelerator', :source => path + 'appcelerator', :source_root => path + 'appcelerator', 'railspath'=>'../../rails-'+rails_gem.version.to_s})
-
-Dir.chdir(app_path) { `rake rails:freeze:gems`; puts "froze" } if freeze
+#
+# add appcelerator files
+#
+APP_GEM = Gem.cache.search('appcelerator').last.full_gem_path
+FileUtils.mkdir "#{p}/public/javascripts"
+FileUtils.mkdir "#{p}/app/services"
 
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/appcelerator.xml", "#{p}/public"
+rails_gem = Gem.cache.search('rails').last
+if rails_gem.version.to_s.to_f >= 2
+  FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/application.rb", "#{p}/app/controllers"
+end
+f = File.open("#{p}/config/environment.rb", 'a')
+f.write("\n\nrequire 'appcelerator'")
+f.close
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/generate", "#{p}/script"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/index.html", "#{p}/public"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/images", "#{p}/public"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/javascripts", "#{p}/public"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/modules", "#{p}/public"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/README", "#{p}"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/routes.rb", "#{p}/config"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/proxy_controller.rb", "#{p}/app/controllers"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/service_broker_controller.rb", "#{p}/app/controllers"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/upload_controller.rb", "#{p}/app/controllers"
+result = ERB.new(File.read("#{p}/app/controllers/service_broker_controller.rb")).result(binding)
+f = File.new("#{p}/app/controllers/service_broker_controller.rb",'w')
+f.write(result)
+f.close
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/service_broker_helper.rb", "#{p}/app/helpers"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/servicetester.html", "#{p}/public"
+FileUtils.cp_r "#{APP_GEM}/appcelerator/templates/test_service.rb", "#{p}/app/services"
+
+puts "Successfully created new Appcelerator project in '#{app_path}'"

data/lib/appcelerator.rb

@@ -5,7 +5,7 @@ require 'md5'
 
 unless defined?(APP_VERSION)
 
-	APP_VERSION = '2.0.1.1'
+	APP_VERSION = '2.0.2'
 	APP_SERVICES = Array.new
  
     def model_name(name)
@@ -47,14 +47,20 @@ unless defined?(APP_VERSION)
        log_to STDOUT
     end	
     
-    Appcelerator::Service.load_services
-    
+    # just do this once, make rails do the implicit loading for us
+    Dir[RAILS_ROOT + '/app/services/*_service.rb'].each do |file|
+        #Dependencies.load_file file
+        name = Inflector.camelize(File.basename(file).chomp('_service.rb')) + 'Service'
+        Object.const_get name
+    end
+    puts Appcelerator::ServiceBroker.diagnostics
+      
     #
     # register a service broker listener for admin appcelerator models
     #
-    sam_proc = Proc.new do |req,type,obj|
+    sam_proc = Proc.new do |request,type,obj|
       resp = {'success'=>true, 'models'=> APP_SERVICES}
-  	  Appcelerator::Dispatcher.instance.outgoing(req,'app.admin.models.response',resp)
+  	  Appcelerator::Dispatcher.instance.outgoing(request,'app.admin.models.response',resp)
     end
     Appcelerator::ServiceBroker.register_listener('app.admin.models.request',sam_proc)
 

data/lib/appcelerator/dispatcher.rb

@@ -1,68 +1,68 @@
 module Appcelerator
-    class Dispatcher
-    	include Singleton
+  module Dispatcher
+	  
+    # dispatch a standard request, called by the service_broker_controller
+    #
+    def self.dispatch_request(request, response, session)
+      message_queue = []
+      extract_messages(request, session) do |in_message|
+        out_messages = ServiceBroker.send(in_message)
+        message_queue.concat(out_messages)
+      end
+      serialize(message_queue, session.session_id, response.body)
+    end
     
-		def serialize(session,body)
-			queue = session['_app_mq']
-			body << '<?xml version="1.0"?>'
-			body << "<messages version='1.0' sessionid='#{session.session_id}'>"
-			if queue
-			  queue.each do |msg|
-				body << msg
-			  end
-			  session['_app_mq']=[]
-			end
-			body << '</messages>'
-		end
-		
-		def outgoing(obj,type,message)
-			queue = obj['session']['_app_mq']
-			if !queue
-			  queue = [];
-			  obj['session']['_app_mq'] = queue
-			end
-			#TODO requestid
-			queue << "<message requestid='' direction='OUTGOING' datatype='JSON' type='#{type}'><![CDATA["
-			queue << message.to_json
-			queue << ']]></message>'
-		end
-		
-		def incoming(session,request,response)
-			body = request.env['RAW_POST_DATA']
-			if body and body != ''
-			   node = REXML::Document.new(body)
-			   node.root.each_element('//message') do |message|
-				  requestid = message.attributes['requestid']
-				  type = message.attributes['type']
-				  text = message.text
-				  msg = JSON.parse(text)
-				  req = {'requestid'=>requestid, 'session'=>session, 'orig_request'=>request}
-				  ServiceBroker.send(req,type,msg)
-			   end
-			end      
-		end
-  end
-end
-
-
-
-# this is the rails dispatcher
-require 'dispatcher'
-
-module ClassMethods
-  def reset_application_and_services!
-    Appcelerator::Service.load_services
-    reset_application_but_not_services!
-  end
-end
-
-Dispatcher.extend(ClassMethods)
-Dispatcher.class_eval do
-  class << self
-    unless method_defined? :reset_application_but_not_services!
-      alias_method :reset_application_but_not_services!, :reset_application!
+    # dispatch a message that was generated in some other way, like the upload_controller
+    #
+    def self.dispatch_message(request, response, session, message_type, params, request_id)
+      msg = Message.new(request, session, message_type, params, request_id)
+      
+      message_queue = ServiceBroker.send(msg)
+      
+      serialize(message_queue, session.session_id, response.body)
+    end
+    
+    def self.extract_messages(request, session)
+      body = request.env['RAW_POST_DATA']
+      if body and body != ''
+        node = REXML::Document.new(body)
+        node.root.each_element('//message') do |message|
+          
+          request_id = message.attributes['requestid']
+          message_type = message.attributes['type']
+          params = JSON.parse(message.text)
+          
+          yield Message.new(request, session, message_type, params, request_id)
+        end
+      end
+    end
+    
+    def self.serialize(message_queue, session_id, output)
+      output << '<?xml version="1.0"?>'
+      output << "<messages version='1.0' sessionid='#{session_id}'>"
+      
+      message_queue.compact!
+      message_queue.each do |msg|
+        if msg.response_type
+          output << "<message requestid='#{msg.request_id}' direction='OUTGOING' datatype='JSON' type='#{msg.response_type}'><![CDATA["
+          output << msg.response.to_json
+          output << ']]></message>'
+        end
+      end
+      
+      output << '</messages>'
+    end
+    
+    class Message
+      attr_accessor :request, :session, :message_type, :params, :request_id, :response_type, :response
+      def initialize(request, session, message_type, params, request_id)
+        @request = request
+        @session = session
+        @message_type = message_type
+        @params = params
+        @request_id = request_id
+      end
     end
-    alias_method :reset_application!, :reset_application_and_services!
   end
 end
 

data/lib/appcelerator/service.rb

@@ -1,195 +1,44 @@
 
 
-module Appcelerator
-	class Service
-	  include Singleton
-    	      
-    def Service.Service(messagetype,handler,responsetype)
-      self.instance.preregister(messagetype,handler,responsetype)
-    end
+module Appcelerator  
+  class Service
+    include Singleton
     
-    def Service.service_scaffold(model)
-      servicename = model_name(model)
-      self.instance.model_class = eval(model.to_s.camelize)
-      %w(create retrieve update delete list assembly search).each do |operation|
-          messagetype = "app."+ servicename +"."+ operation
-          request = messagetype + ".request"
-          response = messagetype + ".response"
-          self.instance.preregister(request,operation,response)
-          APP_SERVICES << {'name'=>name, 'model'=>servicename}
-      end
+    # registration point of standard services
+    def Service.Service(messagetype,handler,responsetype = nil)
+      self.instance.register(messagetype,handler,responsetype)
+    end
+
+    # registration point for service handler filters for authentication, etc 
+    def Service.before_filter(filter)
+      self.instance.before_filters << filter
     end
     
-    #
-    # The following methods are usable by services that call the "service_scaffold" method
-    #  to provide CRUD (and more) operations on a single model object.
-    #
-			def assembly(request,message)
-			  if self.respond_to?(:before_assembly)
-				  request,message = send(:before_assembly,request,message)
-			  end
-			  data = Array.new
-			  @model_class.columns.each do |column|
-			  	  data << {'name'=>column.name,'type'=>column.type, 'limit'=>column.limit, 
-			  	  		   'nullable'=>column.null, 'primary'=>column.primary, 
-			  	  		   'default'=>column.default}
-			  end
-			  response = {'success'=>true,'columns'=>data}
-			  if self.respond_to?(:after_assembly)
-				  response = send(:after_assembly,response)
-			  end
-			  response
-			end
-			
-			def create(request,message)
-			  if self.respond_to?(:before_create)
-				  request,message = send(:before_create,request,message)
-			  end
-			  o = @model_class.new(message)
-			  o.save
-			  response = {'success'=>true,'id'=>o.id}
-			  if self.respond_to?(:after_create)
-				  response = send(:after_create,response)
-			  end
-			  response
-			end
-			
-			def retrieve(request,message)
-			  if self.respond_to?(:before_retrieve)
-				request,message = send(:before_retrieve,request,message)
-			  end
-			  o = @model_class.find(message['id'])
-			  response = {'success'=>true}
-			  o.attributes.each do |key,val|
-				  response[key]=val
-			  end
-			  response
-			  if self.respond_to?(:after_retrieve)
-				  response = send(:after_retrieve,response)
-			  end
-			  response
-			end
-			
-			def update(request,message)
-			  if self.respond_to?(:before_update)
-				request,message = send(:before_update,request,message)
-			  end
-			  o = @model_class.find(message['id'])
-			  return {'success'=>false,'message'=>'record does not exist'} unless o
-			  message.each do |key,value|
-				if o.attributes.has_key?(key)
-				  o[key]=true if value=='true'
-				  o[key]=false if value=='false'
-				  o[key]=value if o[key]!=true && o[key]!=false
-				end
-			  end
-			  o.save!
-			  response = {'success'=>true,'id'=>o.id}
-			  if self.respond_to?(:after_update)
-				  response = send(:after_update,response)
-			  end
-			  response
-			end
-			
-			def delete(request,message)
-			  if self.respond_to?(:before_delete)
-				request,message = send(:before_delete,request,message)
-			  end
-			  @model_class.delete(message['id'])
-			  response = {'success'=>true,'id'=>message['id']}
-			  if self.respond_to?(:after_delete)
-				  response = send(:after_delete,response)
-			  end
-			  response
-			end
-			
-			def search(request,message)
-  			  if self.respond_to?(:before_search)
-  				request,message = send(:before_search,request,message)
-  			  end
-			    query = '%%' + message['query'] + '%%'
-			    conditions_str = Array.new
-			    @model_class.content_columns.each do |col|
-			      name = col.name + ' like ?'
-			      conditions_str << name if col.type == :string
-		      end
-		      
-		      conditions = Array.new
-		      conditions << conditions_str.join(' OR ')
-		      conditions_str.length.times {|e| conditions<<query}
-		      		      
-		      results = @model_class.find(:all,:conditions=>conditions)
-		      response = {'success'=>true, 'rows'=>results, 'total'=>@model_class.count, 'count'=>results.length}
-  			  
-  			  if self.respond_to?(:after_search)
-  				  response = send(:after_search,response)
-  			  end
-  			  response
-		  end
-			
-			def list(request,message)
-			  pk = message['id']
-			  limit = message['limit'] || 100
-			  if pk
-  			    objs = [@model_class.find_by_id(pk)]
-		      else
-  			    objs = @model_class.find(:all,:limit=>limit)
-	      	  end
-			  response = {'success'=>true,'rows'=>objs, 'total'=>@model_class.count}
-			  if self.respond_to?(:after_list)
-				  response = send(:after_list,response)
-			  end
-			  response
-			end
-	  
+    # registration point for post-service-handling filters
+    def Service.after_filter(filter)
+      self.instance.after_filters << filter
+    end
 
-    def self.load_services
-      APP_SERVICES.clear
-      # TODO: remove this and solve the multiple singleton issue
-      Appcelerator::ServiceBroker.clear_listeners
-      Dir[RAILS_ROOT + '/app/services/*_service.rb'].each do |file|
-        
-        name = Inflector.camelize(File.basename(file).chomp('_service.rb')) + 'Service'
-        
-        if Dependencies.load?
-          if defined?(name)
-            klass = eval(name)
-            # clear the service class's existing listeners, if possible
-            klass.instance.clear_listeners
-          end
-          load file
-        else
-          require file[0..-4]
-        end
-        
-        begin
-          klass = eval(name)
-          klass.instance.register_listeners
-        rescue
-          puts 'Unable to find class "'+ name +'" in file "'+ file +'"'
-          puts $!
-        end
+    # for use by message handlers    
+    attr_accessor :request,:params,:session,:message_type,:response,:response_type
+
+     # call this method from a before filter to prevent the remain handlers from running
+    def respond_with(response,response_type=nil)
+      @response = response
+      if response_type
+        @response_type = response_type
       end
-      puts 'done loading services'
-      puts Appcelerator::ServiceBroker.diagnostics
     end
 
-    def initialize
-      @listeners = []
-      @preregistrations = []
-    end
 
-    def preregister(*args)
-      @preregistrations << args
-    end
+
+    # internal
+    attr_accessor :before_filters, :after_filters
     
-    def register_listeners
-      # call after class-load when all methods are defined
-      @listeners = @preregistrations.map do |reg|
-        register(*reg)
-      end
-      @preregistrations.clear
-      @listeners.length
+    def initialize
+      @listeners = []
+      @before_filters = []
+      @after_filters = []
     end
     
     def clear_listeners
@@ -201,56 +50,204 @@ module Appcelerator
       num_cleared
     end
     
-	  def register(msgtype,methodname,responsetype = nil)
-      service = self.class # add to the ServiceProc binding
-		  handler = self.method(methodname)
-		  args = handler.arity
-		  proc = ServiceProc.new do |req,msgtype,obj|
-		   
-		   #
-		   # try and be smart about sending in the request to the
-		   # service based on the arguments he supports
-		   # 
-		   case args
-		   	when 2
-		   		resp = handler.call(req,obj)
-		    when 3
-		    	resp = handler.call(req,obj,req['session'])
-		    when 4
-		    	resp = handler.call(req,obj,req['session'],req['session']['username'])
-		   end
-		   
-		   if responsetype
-			  Dispatcher.instance.outgoing(req,responsetype,resp||{})
-		   end
+    def do_before_filters      
+      @before_filters.each do |filter|
+        method(filter).call()
+        break if @response
+      end
+    end
+   
+    def do_after_filters
+      @after_filters.each do |filter|
+          method(filter).call()
+      end
+    end
+    
+    # handle a message
+    def handle(msg, method_name, response_type)
+      @request = msg.request
+      @session = msg.session
+      @message_type = msg.message_type
+      @params = msg.params
+      @response = nil # this is the handler's response, not the request/response pair
+      @response_type = response_type
+      
+      do_before_filters()
+      
+      # any response added by the before_filters prevents the handler from running
+      if not @response
+        @response = method(method_name).call()
+        
+        do_after_filters()
       end
-		  ServiceBroker.register_listener(msgtype,proc)
+      
+      if @response_type
+        msg.response_type = @response_type
+        msg.response = @response || {}
+      end
+      msg
+    end
+    
+	  def register(message_type, method_name, response_type = nil)
+      # adding to the ServiceProc binding, for preventing dups # this need may have been removed by properly reloading
+      service_name = self.class.name
+        
+		  proc = ServiceProc.new do |msg|
+        # is this const_get stuff important?
+        instance = Object.const_get(service_name).instance
+        instance.handle(msg,method_name,response_type)
+      end
+      
+		  ServiceBroker.register_listener(message_type, proc)
       proc
 	  end
-	
-	  def send_message(req,type,message)
-		  ServiceBroker.send(req,type,message)
-	  end
 	  
-	  def secure_password_matches?(request,message,password_field,password)
-	    
-	    password_obj = message[password_field]
-	    
-      if password_obj
-  	    return Digest::MD5.hexdigest(password + request['authtoken']) == password_obj['auth']
-      end
-	    
-	    false
-	  end
 	end
   
+  # TODO: spin this into another file when we can resolve dependecy issues
+  class CrudService < Service
+    
+    # registration point for crud services
+    def Service.service_scaffold(model)
+      servicename = model_name(model)
+      self.instance.model_class = eval(model.to_s.camelize)
+      %w(create retrieve update delete list assembly search).each do |operation|
+          messagetype = "app."+ servicename +"."+ operation
+          request = messagetype + ".request"
+          response = messagetype + ".response"
+          self.instance.register(request,operation,response)
+          APP_SERVICES << {'name'=>name, 'model'=>servicename}
+      end
+    end
+    
+    attr_accessor :model_class
+    
+    def assembly(request,message)
+      if self.respond_to?(:before_assembly)
+        request,message = send(:before_assembly,request,message)
+      end
+      data = Array.new
+      @model_class.columns.each do |column|
+          data << {'name'=>column.name,'type'=>column.type, 'limit'=>column.limit, 
+                 'nullable'=>column.null, 'primary'=>column.primary, 
+                 'default'=>column.default}
+      end
+      response = {'success'=>true,'columns'=>data}
+      if self.respond_to?(:after_assembly)
+        response = send(:after_assembly,response)
+      end
+      response
+    end
+    
+    def create(request,message)
+      if self.respond_to?(:before_create)
+        request,message = send(:before_create,request,message)
+      end
+      o = @model_class.new(message)
+      o.save
+      response = {'success'=>true,'id'=>o.id}
+      if self.respond_to?(:after_create)
+        response = send(:after_create,response)
+      end
+      response
+    end
+    
+    def retrieve(request,message)
+      if self.respond_to?(:before_retrieve)
+      request,message = send(:before_retrieve,request,message)
+      end
+      o = @model_class.find(message['id'])
+      response = {'success'=>true}
+      o.attributes.each do |key,val|
+        response[key]=val
+      end
+      response
+      if self.respond_to?(:after_retrieve)
+        response = send(:after_retrieve,response)
+      end
+      response
+    end
+    
+    def update(request,message)
+      if self.respond_to?(:before_update)
+      request,message = send(:before_update,request,message)
+      end
+      o = @model_class.find(message['id'])
+      return {'success'=>false,'message'=>'record does not exist'} unless o
+      message.each do |key,value|
+      if o.attributes.has_key?(key)
+        o[key]=true if value=='true'
+        o[key]=false if value=='false'
+        o[key]=value if o[key]!=true && o[key]!=false
+      end
+      end
+      o.save!
+      response = {'success'=>true,'id'=>o.id}
+      if self.respond_to?(:after_update)
+        response = send(:after_update,response)
+      end
+      response
+    end
+    
+    def delete(request,message)
+      if self.respond_to?(:before_delete)
+      request,message = send(:before_delete,request,message)
+      end
+      @model_class.delete(message['id'])
+      response = {'success'=>true,'id'=>message['id']}
+      if self.respond_to?(:after_delete)
+        response = send(:after_delete,response)
+      end
+      response
+    end
+    
+    def search(request,message)
+        if self.respond_to?(:before_search)
+        request,message = send(:before_search,request,message)
+        end
+        query = '%%' + message['query'] + '%%'
+        conditions_str = Array.new
+        @model_class.content_columns.each do |col|
+          name = col.name + ' like ?'
+          conditions_str << name if col.type == :string
+        end
+        
+        conditions = Array.new
+        conditions << conditions_str.join(' OR ')
+        conditions_str.length.times {|e| conditions<<query}
+                  
+        results = @model_class.find(:all,:conditions=>conditions)
+        response = {'success'=>true, 'rows'=>results, 'total'=>@model_class.count, 'count'=>results.length}
+        
+        if self.respond_to?(:after_search)
+          response = send(:after_search,response)
+        end
+        response
+    end
+    
+    def list(request,message)
+      pk = message['id']
+      limit = message['limit'] || 100
+      if pk
+          objs = [@model_class.find_by_id(pk)]
+        else
+          objs = @model_class.find(:all,:limit=>limit)
+          end
+      response = {'success'=>true,'rows'=>objs, 'total'=>@model_class.count}
+      if self.respond_to?(:after_list)
+        response = send(:after_list,response)
+      end
+      response
+    end 
+  end
+    
   #
   # Class to allow inspection and equality checking (for adding to sets)
   # TODO: remove the to_s in eql? and hash when the singleton issue is resolved 
   #
   class ServiceProc < Proc
     def self.vars
-        [:msgtype, :service, :methodname, :responsetype]
+        [:message_type, :service_name, :method_name, :response_type]
     end
     
     def method_missing name
@@ -258,7 +255,8 @@ module Appcelerator
     end
     
     def to_s
-        "#{msgtype} -> #{service}.#{methodname} -> #{responsetype}"
+        service = Object.const_get(service_name).instance
+        "#{message_type} -> #{service.before_filters} #{service_name}.#{method_name} #{service.after_filters} -> #{response_type}"
     end
     
     def eql?(other)
@@ -288,5 +286,5 @@ module Appcelerator
       end
       return true
     end
-  end
-end
+  end  
+end