appbase 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4287ccf943cbb1549e3524e7e20d676f0bc1fc16
-  data.tar.gz: 91a967f151ead8e747170cc8e4129162b2b4d7ff
+  metadata.gz: d24b5aefaba7ab3de7fa709dced97ff3d2b24539
+  data.tar.gz: 8a666834bc752c9128b37e94845ae4ca7272f192
 SHA512:
-  metadata.gz: d5c3719f395cd41c315df6ae9af9efd9f8e683af7ed464eb9aa903d999e19d224cad5f9a84c859feac49f543589965ac6e258cb2c5d60e2bbaf1562c0a051ff1
-  data.tar.gz: 10597b8d9d43506240431a9f6e89b886e073841c90363c69cf7e26c5336dd080f5ac656e8f5380582f268f4794c6d732bf4db3476be107a1a912a7892f6f20e4
+  metadata.gz: b41847490b989888115964cda8848be3d3417117391958dadebc0d6696f01daaa090f0e99fedb4c7177e0763f370cb067a73e46b90e1915ecd6b4a06a3ecb2c0
+  data.tar.gz: 129624fb6e14b2c6ef94a0f3033997101e79b3b7ac50081ef9f93f38be7924ecb3811d42ec62eaf6c5376725d06da3dcd5fb5286d50aa227767e85f960e6f750

data/README.md

@@ -1,4 +1,7 @@
 [![Build Status](https://travis-ci.org/bestmike007/appbase.svg?branch=master)](https://travis-ci.org/bestmike007/appbase)
+[![Code Climate](https://codeclimate.com/github/bestmike007/appbase/badges/gpa.svg)](https://codeclimate.com/github/bestmike007/appbase)
+[![Test Coverage](https://codeclimate.com/github/bestmike007/appbase/badges/coverage.svg)](https://codeclimate.com/github/bestmike007/appbase)
+[![Gem Version](https://badge.fury.io/rb/appbase.svg)](http://badge.fury.io/rb/appbase)
 
 Nowadays BaaS and mBaaS platforms (e.g. [firebase](https://www.firebase.com/), [parse](https://www.parse.com/), [appbase.io](https://appbase.io/)) abound. Open source solutions (e.g. [usergrid](http://usergrid.incubator.apache.org/) using LAMP, [helios](http://helios.io/) using Ruby, [deployd](http://deployd.com/) and [StrongLoop](http://strongloop.com/) using nodejs, and a lot more) are also available. And appbase is much less than those.
 
@@ -154,7 +157,7 @@ Basic CRUD api conforms to the representational state transfer (REST) architectu
 Request to create a model with JSON serialized body:
 
 ```
-PUT /_api/note HTTP/1.1
+POST /_api/note HTTP/1.1
 HOST xxx
 Content-Type: application/json
 
@@ -179,7 +182,7 @@ HTTP/1.1 200 OK
 
 #### Update
 
-Almost the same as create except for adding the `:id` parameter (e.g. `/_api/note/:id`):
+Almost the same as create except for using `PUT` and adding the `:id` parameter (e.g. `/_api/note/:id`):
 
 ```
 PUT /_api/note/1 HTTP/1.1
@@ -254,4 +257,4 @@ You're welcome to contribute to this project by creating an issue / a pull reque
 
 ## License
 
-Appbase is released under the [MIT License](http://opensource.org/licenses/MIT).
+Appbase is released under the [MIT License](http://opensource.org/licenses/MIT).

data/lib/appbase/controllers/app_base_controller.rb

@@ -27,43 +27,42 @@ class AppBaseController < ActionController::Base
       -
     end
     
-    def add_create_stub(model)
+    def permits(model, arg_str=false)
+      if arg_str
+        "[#{model.columns.map { |item| ":" + item.name }.join(", ")}]"
+      else
+        model.columns.map { |item| item.name.to_sym }
+      end
+    end
+    
+    def add_create_or_update_stub(op, model, prepare)
       m = model.name
-      permits = model.columns.map { |item| item.name }.to_json
       self.class_eval %-
-        def create_#{AppBase.underscore m}
-          obj = #{m}.new(params.except(:action, :controller, :id).permit(#{permits}))
-          if !#{m}.allow_create?(current_user, obj)
-            render json: { status: "error", msg: "unauthorized" }
-          else
-            obj.save!
-            render json: { status: 'ok', id: obj.id }
-          end
+        def #{op}_#{AppBase.underscore m}
+          #{prepare}
+          raise "unauthorized" if !#{m}.allow_#{op}?(current_user, obj)
+          obj.save!
+          rs = { status: 'ok' }
+          #{ 'rs[:id] = obj.id' if op == :create }
+          render json: rs
         rescue Exception => e
           render json: { status: 'error', msg: e.to_s }
         end
       -
     end
+    private :add_create_or_update_stub
+    
+    def add_create_stub(model)
+      add_create_or_update_stub :create, model, %-
+          obj = #{model.name}.new(params.except(:action, :controller, :id).permit(#{permits(model, true)}))
+      -
+    end
     
     def add_update_stub(model)
-      m = model.name
-      permits = model.columns.map { |item| item.name }.to_json
-      self.class_eval %-
-        def update_#{AppBase.underscore m}
-          obj = #{m}.find(params[:id])
-          if obj.nil?
-            return render json: { status: 'error', msg: 'not_found' }
-          end
-          obj.update_attributes(params.except(:action, :controller, :id).permit(#{permits}))
-          if !#{m}.allow_update?(current_user, obj)
-            render json: { status: "error", msg: "unauthorized" }
-          else
-            obj.save!
-            render json: { status: 'ok' }
-          end
-        rescue Exception => e
-          render json: { status: 'error', msg: e.to_s }
-        end
+      add_create_or_update_stub :update, model, %-
+          obj = #{model.name}.find(params[:id])
+          raise 'not_found' if obj.nil?
+          obj.update_attributes(params.except(:action, :controller, :id).permit(#{permits(model, true)}))
       -
     end
     
@@ -89,7 +88,6 @@ class AppBaseController < ActionController::Base
     
     def add_query_stub(model)
       m = model.name
-      columns = model.columns.map{|c|c.name}
       self.class_eval %-
         def query_#{AppBase.underscore m}
           query = #{m}.accessible_by(current_user)
@@ -141,36 +139,69 @@ class AppBaseController < ActionController::Base
     end
     
     def add_rpc_method_stub(bound_method, auth=false)
-      m = bound_method.receiver.name
-      mn = bound_method.name
-      parameters = bound_method.parameters
-      if auth && (parameters.count == 0 || parameters[0][0] != :req)
-        raise "#{m}.#{mn} does not accept current user identity as the first parameter. Using `expose_to_appbase :method_name, auth: false` to expose #{m}.#{mn} to appbase without user authentication."
+      RpcMethodStubHelper.new(bound_method, auth).add_stub(self)
+    end
+    
+    class RpcMethodStubHelper
+      
+      def initialize(bound_method, auth=false)
+        @bound_method = bound_method
+        @auth = auth
+        @method_name = bound_method.name
+        @model_name = bound_method.receiver.name.to_s.extend(AppBase::StringExtension)
+        init
       end
-      need_params = false
-      if parameters.count > 0 && parameters.last[0] == :opt
-        need_params = true
-        parameters = parameters[(auth ? 1 : 0)..-2]
-      else
-        parameters = parameters[(auth ? 1 : 0)..-1]
+      
+      def add_stub(controller)
+        controller.class_eval %-
+          def rpc_#{@model_name.underscore}_#{@method_name}
+            #{@requires.map{|p|"params.require #{p}"}.join(';')}
+            render json: { status: 'ok', data: #{@model_name}.#{@method_name}(#{@parameters.join(', ')}) }
+          rescue Exception => e
+            render json: { status: 'error', msg: e.to_s }
+          end
+        -
       end
-      if parameters.find{|p|p[0]!=:req}
-        raise "Error exposing #{m}.#{mn} to appbase engine, appbase does not support rest/optional parameters, use options instead!"
+      
+      private
+      def init
+        init_parameters do |parameters, need_params|
+          @requires = parameters.map{|p|":#{p[1]}"}
+          @parameters = @auth ? ['current_user'] : []
+          @requires.each { |p| @parameters << "params[#{p}]" }
+          if need_params
+            @parameters.push "params.except(:action, :controller#{@requires.count > 0 ? ", #{@requires.join(', ')}" : ""})"
+          end
+        end
       end
-      requires = parameters.map{|p|":#{p[1]}"}
-      parameters = auth ? ['current_user'] : []
-      requires.each { |p| parameters << "params[#{p}]" }
-      if need_params
-        parameters.push "params.except(:action, :controller#{requires.count > 0 ? ", #{requires.join(', ')}" : ""})"
+      
+      def pre_init_parameters(parameters)
+        if @auth && (parameters.count == 0 || parameters[0][0] != :req)
+          raise "#{@model_name}.#{@method_name} does not accept current user identity as the first parameter. Using `expose_to_appbase :method_name, auth: false` to expose #{@model_name}.#{@method_name} to appbase without user authentication."
+        end
       end
-      self.class_eval %-
-        def rpc_#{AppBase.underscore m}_#{mn}
-          #{requires.map{|p|"params.require #{p}"}.join(';')}
-          render json: { status: 'ok', data: #{m}.#{mn}(#{parameters.join(', ')}) }
-        rescue Exception => e
-          render json: { status: 'error', msg: e.to_s }
+      
+      def post_init_parameters(parameters)
+        if parameters.find{|p|p[0]!=:req}
+          raise "Error exposing #{@model_name}.#{@method_name} to appbase engine, appbase does not support rest/optional parameters, use options instead!"
         end
-      -
+      end
+      
+      def init_parameters
+        parameters = @bound_method.parameters
+        pre_init_parameters(parameters)
+        
+        need_params = false
+        if parameters.count > 0 && parameters.last[0] == :opt
+          need_params = true
+          parameters = parameters[(@auth ? 1 : 0)..-2]
+        else
+          parameters = parameters[(@auth ? 1 : 0)..-1]
+        end
+        
+        post_init_parameters(parameters)
+        yield parameters, need_params
+      end
     end
     
   end

data/lib/appbase/model_concern.rb

@@ -3,6 +3,129 @@ require 'active_support'
 module AppBase
   
   module ModelConcern
+      
+    class InvalidUsage < Exception
+    end
+    
+    class ModelConcernHelper
+      
+      private
+      
+      def validate_crud(crud)
+        if [:create, :update, :delete, :query].index(crud).nil?
+          raise "Unsupported crud operation: #{crud}, available options: create, update, delete, query"
+        end
+      end
+      
+      def model_inject(method_name=nil, &block)
+        AppBase::Engine.after_initialized do
+          user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
+          if method_name.nil?
+            method_body = block.call(user_identity_attr)
+            @model.class_eval method_body
+          else
+            @model.define_singleton_method method_name.to_sym, &block
+          end
+        end
+      end
+      
+      def show_usage(crud)
+        raise %-
+          allow_#{crud} usage:
+            allow_#{crud} :mine
+            allow_#{crud} :#{ crud == :query ? 'within' : 'if' } => :a_singleton_method
+            allow_#{crud} :#{ crud == :query ? 'within' : 'if' } do |current_user_identity#{ crud == :query ? '' : ', model_instance' }|
+              # #{ crud == :query ? 'return fitlered query, e.g. Note.where(:user_id => current_user_identity.id)' : 'return true if allowed' }
+            end
+        -
+      end
+        
+      def allow_mine(crud)
+        model_inject do |user_identity_attr|
+          crud == :query ? %-
+            def self.accessible_by(user)
+              #{@model.name}.where(:#{user_identity_attr} => user.id)
+            end
+          - : %-
+            def self.allow_#{crud}?(user, obj)
+              user.id == obj.#{user_identity_attr}
+            end
+          -
+        end
+      end
+      
+      def allow_criteria_with_block(crud, block)
+        show_usage(crud) if crud == :query && block.parameters.count != 1
+        show_usage(crud) if crud != :query && block.parameters.count != 2
+        model_inject crud == :query ? :accessible_by : "allow_#{crud}", &block
+      end
+      
+      def allow_criteria_with_method_alias(crud, method_name)
+        show_usage(crud) if method_name.nil? || !method_name.instance_of?(Symbol)
+        model_inject do |user_identity_attr|
+          crud == :query ? %-
+            def self.accessible_by(user)
+              #{@model.name}.#{method_name} user
+            end
+          - : %-
+            def self.allow_#{crud}?(user, obj)
+              #{@model.name}.#{method_name} user, obj
+            end
+          -
+        end
+      end
+      
+      public
+      
+      def crud_allow(crud, criteria=:mine, &block)
+        validate_crud crud
+        
+        if criteria == :mine
+          allow_mine crud
+        else
+          key = crud == :query ? :within : :if
+          if criteria.instance_of? Hash
+            allow_criteria_with_method_alias(crud, criteria[key])
+          else
+            show_usage(crud) if criteria != key || !block_given?
+            allow_criteria_with_block(crud, block)
+          end
+        end
+        AppBase::Registry.register_crud @model, crud
+      end
+      
+      def symbol_array_manipulate(op, source, options)
+        raise InvalidUsage if op != :only && op != :except
+        if options.has_key? op
+          operands = options[op]
+          operands = [operands] if operands.instance_of?(String) || operands.instance_of?(Symbol)
+          raise InvalidUsage unless operands.instance_of?(Array)
+          operands = operands.map {|c|c.to_sym}
+          source.send({ only: '&', except: "-" }[op], operands)
+        else
+          source
+        end
+      end
+      
+      private
+      def initialize(model)
+        @model = model
+      end
+      
+      class << self
+        
+        def [](model)
+          raise "Invalid model" if model.class != Class
+          helpers[model] ||= ModelConcernHelper.new(model)
+        end
+        
+        private
+        def helpers
+          @helpers ||= {}
+        end
+      end
+      
+    end
   
     extend ActiveSupport::Concern
     
@@ -19,120 +142,42 @@ module AppBase
         end
       end
       
-      def appbase_allow(crud, criteria=:mine, &block)
-        if [:create, :update, :delete, :query].index(crud).nil?
-          raise "Unsupported crud operation: #{crud}, available options: create, update, delete, query"
-        end
-        model = self
-        if criteria == :mine
-          # allow_xxx :mine or simply allow_xxx
-          AppBase::Engine.after_initialized do
-            user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
-            model.class_eval crud == :query ? %-
-              def self.accessible_by(user)
-                #{model.name}.where(:#{user_identity_attr} => user.id)
-              end
-            - : %-
-              def self.allow_#{crud}?(user, obj)
-                user.id == obj.#{user_identity_attr}
-              end
-            -
-          end
-        elsif crud != :query && criteria == :if && block_given? && block.parameters.count == 2
-          # allow_xxx :if do; end
-          AppBase::Engine.after_initialized do
-            user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
-            model.define_singleton_method "allow_#{crud}".to_sym, &block
-          end
-        elsif crud == :query && criteria == :within && block_given? && block.parameters.count == 1
-          # allow_query :within {|current_user| Model.where(...)}
-          AppBase::Engine.after_initialized do
-            user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
-            model.define_singleton_method :accessible_by, &block
-          end
-        elsif crud != :query && riteria.instance_of?(Hash) && criteria.has_key?(:if) && criteria[:if].instance_of?(Symbol)
-          # :if => :a_singleton_method
-          AppBase::Engine.after_initialized do
-            user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
-            model.class_eval %-
-              def self.allow_#{crud}?(user, obj)
-                #{model.name}.#{criteria[:if]} user
-              end
-            -
-          end
-        elsif crud == :query && criteria.instance_of?(Hash) && criteria.has_key?(:within) && criteria[:within].instance_of?(Symbol)
-          # allow_query :within => :a_singleton_query_method
-          AppBase::Engine.after_initialized do
-            user_identity_attr = "#{AppBase::Engine::UserIdentity.underscore}_id"
-            model.class_eval %-
-              def self.accessible_by(user)
-                #{model.name}.#{criteria[:within]} user
-              end
-            -
-          end
-        else
-          raise %-
-            allow_#{crud} usage:
-              allow_#{crud} :mine
-              allow_#{crud} :#{ crud == :query ? 'within' : 'if' } => :a_singleton_method
-              allow_#{crud} :#{ crud == :query ? 'within' : 'if' } do |current_user_identity#{ crud == :query ? '' : ', model_instance' }|
-                # #{ crud == :query ? 'return fitlered query, e.g. Note.where(:user_id => current_user_identity.id)' : 'return true if allowed' }
-              end
-          -
-        end
-        AppBase::Registry.register_crud self, crud
-      end
-      
       def allow_create(criteria=:mine, &block)
-        appbase_allow(:create, criteria, &block)
+        appbase_helper.crud_allow(:create, criteria, &block)
       end
       
       def allow_update(criteria=:mine, &block)
-        appbase_allow(:update, criteria, &block)
+        appbase_helper.crud_allow(:update, criteria, &block)
       end
       
       def allow_delete(criteria=:mine, &block)
-        appbase_allow(:delete, criteria, &block)
+        appbase_helper.crud_allow(:delete, criteria, &block)
       end
       
       def allow_query(criteria=:mine, &block)
-        appbase_allow(:query, criteria, &block)
+        appbase_helper.crud_allow(:query, criteria, &block)
       end
       
       def restrict_query_columns(options={})
-        show_usage = proc {
-          raise %-
-            restrict_query_columns usage:
-              restrict_query_columns <only | except>: <single_column | column_list>
-            examples:
-              restrict_query_columns only: [:user_id, :created_at, :updated_at]
-              restrict_query_columns only: :updated_at
-              restrict_query_columns except: [:content]
-          -
-        }
-        show_usage.call if !options || !options.instance_of?(Hash)
+        raise InvalidUsage if !options || !options.instance_of?(Hash)
         columns = self.columns.map{|c|c.name.to_sym}
-        # on columns
-        if options.has_key? :only
-          on_columns = options[:only]
-          on_columns = [on_columns] if on_columns.instance_of?(String) || on_columns.instance_of?(Symbol)
-          show_usage.call unless on_columns.instance_of?(Array)
-          on_columns = on_columns.map {|c|c.to_sym}
-          columns &= on_columns
-        end
-        # except columns
-        if options.has_key? :except
-          except_columns = options[:except]
-          except_columns = [except_columns] if except_columns.instance_of?(String) || except_columns.instance_of?(Symbol)
-          show_usage.call unless except_columns.instance_of?(Array)
-          except_columns = except_columns.map {|c|c.to_sym}
-          columns -= except_columns
-        end
+        
+        columns = appbase_helper.symbol_array_manipulate :only, columns, options
+        columns = appbase_helper.symbol_array_manipulate :except, columns, options
         
         self.define_singleton_method :appbase_queryable_columns do
           columns
         end
         
+      rescue InvalidUsage
+        raise %-
+          restrict_query_columns usage:
+            restrict_query_columns <only | except>: <single_column | column_list>
+          examples:
+            restrict_query_columns only: [:user_id, :created_at, :updated_at]
+            restrict_query_columns only: :updated_at
+            restrict_query_columns except: [:content]
+        -
       end
       
       def appbase_queryable_operators
@@ -140,38 +185,13 @@ module AppBase
       end
         
       def restrict_query_operators(*columns)
-        show_usage = proc {
-          raise %-
-            restrict_query_operators usage:
-              restrict_query_operators :column1, :column2, <only | except>: <:equal | :compare | :in>
-            examples:
-              restrict_query_operators :user_id, :created_at, :updated_at, only: [:equal, :compare]
-              restrict_query_operators :user_id, :created_at, :updated_at, except: :in
-              restrict_query_operators :title, only: :equal
-          -
-        }
-        show_usage.call if columns.count < 2 || !columns.last.instance_of?(Hash)
+        check_before_restrict_query_operators columns
         *columns, options = columns
-        show_usage.call unless options.has_key?(:only) || options.has_key?(:except)
         operators = appbase_queryable_operators
         
         set = [:equal, :compare, :in]
-        # on columns
-        if options.has_key? :only
-          allows = options[:only]
-          allows = [allows] if allows.instance_of?(String) || allows.instance_of?(Symbol)
-          show_usage.call unless allows.instance_of?(Array)
-          allows = allows.map {|c|c.to_sym}
-          set &= allows
-        end
-        # except columns
-        if options.has_key? :except
-          excepts = options[:except]
-          excepts = [excepts] if excepts.instance_of?(String) || excepts.instance_of?(Symbol)
-          show_usage.call unless excepts.instance_of?(Array)
-          excepts = excepts.map {|c|c.to_sym}
-          set -= excepts
-        end
+        set = appbase_helper.symbol_array_manipulate :only, set, options
+        set = appbase_helper.symbol_array_manipulate :except, set, options
         
         columns.each do |c|
           operators[c.to_sym] = set
@@ -180,10 +200,28 @@ module AppBase
         self.define_singleton_method :appbase_queryable_operators do
           operators
         end
-        
+      rescue InvalidUsage
+        raise %-
+          restrict_query_operators usage:
+            restrict_query_operators :column1, :column2, <only | except>: <:equal | :compare | :in>
+          examples:
+            restrict_query_operators :user_id, :created_at, :updated_at, only: [:equal, :compare]
+            restrict_query_operators :user_id, :created_at, :updated_at, except: :in
+            restrict_query_operators :title, only: :equal
+        -
       end
       
+      private
+      
+      def check_before_restrict_query_operators(columns)
+        raise InvalidUsage if columns.count < 2 || !columns.last.instance_of?(Hash)
+        options = columns.last
+        raise InvalidUsage unless options.has_key?(:only) || options.has_key?(:except)
+      end
       
+      def appbase_helper
+        ModelConcernHelper[self]
+      end
     end
     
   end

data/lib/appbase/railtie.rb

@@ -11,90 +11,156 @@ module AppBase
     
     class << self
       
-      initialized = false
-      config = nil
-      hooks = []
+      class RpcMethodInitializer
+        
+        def initialize(config)
+          @model = config[:model]
+          @method = config[:method]
+          @auth = config[:auth]
+        end
+        
+        def init
+          pre_init
+          add_controller_stub
+          add_route
+        end
+        
+        private
+        def pre_init
+          model_name = @model.name
+          if !@model.respond_to?(@method)
+            raise "#{model_name} does not respond to #{@method}."
+          end
+        end
+        
+        def add_controller_stub
+          bound_method = @model.method @method
+          AppBaseController.add_rpc_method_stub(bound_method, @auth)
+        end
+        
+        def add_route
+          model_name_underscore = AppBase.underscore @model.name
+          method_name = @method
+          AppBase::Engine.routes.append do
+            post "/#{model_name_underscore}/#{method_name}" => "app_base#rpc_#{model_name_underscore}_#{method_name}"
+          end
+        end
+      end
+      
+      class CrudInitializer
+        
+        def initialize(model, op)
+          @model = model
+          @op = op
+          @http_methods = { create: :post, update: :put, delete: :delete, query: :get }
+        end
+        
+        def init
+          pre_init
+          add_controller_stub
+          add_route
+        end
+        
+        private
+        def pre_init
+          raise "Unexpected crud operation: #{@op}" if !@http_methods.has_key?(@op)
+        end
+        
+        def add_controller_stub
+          AppBaseController.send "add_#{@op}_stub".to_sym, @model
+        end
+        
+        def add_route
+          model_name_underscore = AppBase.underscore @model.name
+          url_path = "/#{model_name_underscore}"
+          url_path += "/:id" if @op == :update || @op == :delete
+          http_method = @http_methods[@op]
+          op = @op
+          AppBase::Engine.routes.append do
+            match url_path, to: "app_base##{op}_#{model_name_underscore}", via: http_method
+          end
+        end
+        
+      end
       
-      define_method :bootstrap do |app_config|
-        return if initialized
-        config = app_config.appbase
-        
-        # initialize user identity
-        if config.user_identity.nil?
-          raise "AppBase configuration error: please use `config.appbase.user_identity = :UserIdentity` to specify the user identity model; and implement UserIdentity.authenticate_by_token(user, token):UserIdentity method."
-        end
-        user_identity = Object.const_get config.user_identity.to_sym
-        if !user_identity.respond_to?(:authenticate_by_token) || user_identity.method(:authenticate_by_token).parameters.count != 2
-          raise "It's required to implement UserIdentity.authenticate_by_token(user, token):UserIdentity method."
-        end
-        AppBase::Engine::UserIdentity = config.user_identity.to_s.extend AppBase::StringExtension
-        AppBaseController.define_useridentity config.user_identity, config.token_store, config.token_key_user, config.token_key_session
-        
-        # initialize crud stubs
-        AppBase::Registry.each_crud config.models do |model, op|
-          model_name_underscore = AppBase.underscore model.name
-          case op
-          when :create
-            AppBaseController.add_create_stub(model)
-            AppBase::Engine.routes.append do
-              put "/#{model_name_underscore}" => "app_base#create_#{model_name_underscore}"
-            end
-          when :update
-            AppBaseController.add_update_stub(model)
-            AppBase::Engine.routes.append do
-              put "/#{model_name_underscore}/:id" => "app_base#update_#{model_name_underscore}"
-            end
-          when :delete
-            AppBaseController.add_delete_stub(model)
-            AppBase::Engine.routes.append do
-              delete "/#{model_name_underscore}/:id" => "app_base#delete_#{model_name_underscore}"
-            end
-          when :query
-            AppBaseController.add_query_stub(model)
-            AppBase::Engine.routes.append do
-              get "/#{model_name_underscore}" => "app_base#query_#{model_name_underscore}"
-            end
+      class AppBaseEngineInitializer
+        
+        def initialize
+          @initialized = false
+          @hooks = []
+        end
+        
+        def bootstrap(app_config)
+          return if @initialized
+          @config = app_config.appbase
+          initialize_user_identity
+          initialize_crud_stubs
+          initialize_rpc_stubs
+          finilize_routes
+          post_initialize
+          @initialized = true
+        end
+        
+        def after_initialized(&block)
+          if @initialized
+            block.call
           else
-            raise "Unexpected crud operation: #{op}"
+            @hooks << block
           end
         end
         
-        # initialize rpc stubs
-        AppBase::Registry.each_rpc do |r|
-          if !r[:model].respond_to? r[:method]
-            raise "#{r[:model].name} does not respond to #{r[:method]}."
+        private
+        
+        def pre_init_user_identity
+          if @config.user_identity.nil?
+            raise "AppBase configuration error: please use `config.appbase.user_identity = :UserIdentity` to specify the user identity model; and implement UserIdentity.authenticate_by_token(user, token):UserIdentity method."
           end
-          bound_method = r[:model].method r[:method]
-          AppBaseController.add_rpc_method_stub(bound_method, r[:auth])
-          AppBase::Engine.routes.append do
-            post "/#{AppBase.underscore r[:model].name}/#{r[:method]}" => "app_base#rpc_#{AppBase.underscore r[:model].name}_#{r[:method]}"
+          user_identity = Object.const_get @config.user_identity.to_sym
+          if !user_identity.respond_to?(:authenticate_by_token) || user_identity.method(:authenticate_by_token).parameters.count != 2
+            raise "It's required to implement UserIdentity.authenticate_by_token(user, token):UserIdentity method."
           end
         end
         
-        # finalize appbase routes
-        AppBase::Engine.routes.draw do
-          get "/appbase_version" => "app_base#version"
+        def initialize_user_identity
+          pre_init_user_identity
+          AppBase::Engine.const_set :UserIdentity, @config.user_identity.to_s.extend(AppBase::StringExtension)
+          AppBaseController.define_useridentity @config.user_identity, @config.token_store, @config.token_key_user, @config.token_key_session
         end
         
-        # after initialized
-        blocks, hooks = hooks, []
-        blocks.each do |block|
-          block.call
+        def initialize_crud_stubs
+          AppBase::Registry.each_crud @config.models do |model, op|
+            CrudInitializer.new(model, op).init
+          end
         end
-        initialized = true
         
+        def initialize_rpc_stubs
+          AppBase::Registry.each_rpc do |r|
+            RpcMethodInitializer.new(r).init
+          end
+        end
+        
+        def finilize_routes
+          AppBase::Engine.routes.draw do
+            get "/appbase_version" => "app_base#version"
+          end
+        end
+        
+        def post_initialize
+          blocks, @hooks = @hooks, []
+          blocks.each do |block|
+            block.call
+          end
+        end
       end
       
-      define_method :after_initialized do |&block|
-        if initialized
-          block.call
-        else
-          hooks << block
-        end
+      def bootstrap(config)
+        @initializer = AppBaseEngineInitializer.new if !@initializer
+        @initializer.bootstrap(config)
       end
       
-      define_method :config do
-        config
+      def after_initialized(&block)
+        @initializer = AppBaseEngineInitializer.new if !@initializer
+        @initializer.after_initialized(&block)
       end
       
     end
@@ -102,26 +168,35 @@ module AppBase
   end
 
   class Railtie < Rails::Railtie
-
-    # default values for appbase configuration
-    config.appbase = ActiveSupport::OrderedOptions.new
-    config.appbase.enabled = false
-    config.appbase.mount = "/appbase"
-    config.appbase.user_identity = nil
-    config.appbase.token_store = :cookies # :cookies, :headers, :params
-    config.appbase.token_key_user = :u
-    config.appbase.token_key_session = :s
-    config.appbase.models = []
     
-    initializer "appbase.configure_route", :after => :add_routing_paths do |app|
-      
+    class << self
+      private
+      def setup_default(config)
+        return if config.respond_to? :appbase
+        # default values for appbase configuration
+        config.appbase = ActiveSupport::OrderedOptions.new
+        config.appbase.enabled = false
+        config.appbase.mount = "/appbase"
+        config.appbase.user_identity = nil
+        config.appbase.token_store = :cookies # :cookies, :headers, :params
+        config.appbase.token_key_user = :u
+        config.appbase.token_key_session = :s
+        config.appbase.models = []
+      end
+    end
+
+    def enabled
       if File.basename(ENV['_']) == 'rake'
         puts "Running with `rake #{$*.join(' ')}`"
       end
-      
-      if config.appbase.enabled && (File.basename(ENV['_']) != 'rake' || $*[0] == 'routes')
+      config.appbase.enabled && (File.basename(ENV['_']) != 'rake' || $*[0] == 'routes')
+    end
+    
+    setup_default config
+    
+    initializer "appbase.configure_route", :after => :add_routing_paths do |app|
+      if enabled
         AppBase::Engine.bootstrap app.config
-        
         app.routes.append do
           mount AppBase::Engine => Rails.application.config.appbase.mount
         end

data/lib/appbase/registry.rb

@@ -23,36 +23,64 @@ module AppBase
     # used once upon rails startup, cannot be reloaded by spring.
     class << Registry
       
-      rpc_methods = []
-      crud_permissions = []
-      
-      define_method :register_rpc do |model, method_name, options={}|
-        model = Object.const_get(model.to_sym) if model.instance_of?(String) || model.instance_of?(Symbol)
-        method_name = method_name.to_sym
-        auth = options.has_key?(:auth) ? options[:auth] : true
-        if rpc_methods.find{ |r| r[:model] == model && r[:method] == method_name }.nil?
-          rpc_methods << { model: model, method: method_name, auth: auth }
-        else
-          raise "#{model}.#{method_name} has already been registered"
+      class RegistryTable
+        
+        def initialize
+          @rpc_methods = []
+          @crud_permissions = []
+        end
+        
+        def contains_rpc_registry(item)
+          !@rpc_methods.find{ |r| r[:model] == item[:model] && r[:method] == item[:method] }.nil?
+        end
+        
+        def register_rpc(model, method_name, options={})
+          rpc_registry_item = {
+            model: (model.instance_of?(String) || model.instance_of?(Symbol)) ? Object.const_get(model.to_sym) : model,
+            method: method_name.to_sym,
+            auth: options.has_key?(:auth) ? options[:auth] : true
+          }
+          raise "#{model}.#{method_name} has already been registered" if contains_rpc_registry(rpc_registry_item)
+          @rpc_methods << rpc_registry_item
+        end
+        
+        def register_crud(model, crud)
+          if @crud_permissions.find{ |r| r[:model] == model && r[:crud] == crud }.nil?
+            @crud_permissions << { model: model, crud: crud }
+          end
+        end
+      
+        def each_rpc(&block)
+          @rpc_methods.each(&block)
+        end
+        
+        def each_crud(*models, &block)
+          models = models.flatten.map { |model| (model.instance_of?(Symbol) || model.instance_of?(String)) ? Object.const_get(model) : model }
+          @crud_permissions.each do |r|
+            block.call r[:model], r[:crud] if models.index(r[:model])
+          end
         end
       end
       
-      define_method :each_rpc do |&block|
-        rpc_methods.each &block
+      def register_rpc(model, method_name, options={})
+        instance.register_rpc(model, method_name, options)
       end
       
-      define_method :register_crud do |model, crud|
-        if crud_permissions.find{ |r| r[:model] == model && r[:crud] == crud }.nil?
-          crud_permissions << { model: model, crud: crud }
-        end
+      def register_crud(model, crud)
+        instance.register_crud(model, crud)
       end
       
-      define_method :each_crud do |*models, &block|
-        models = models[0] if models.count == 1 && models.instance_of?(Array)
-        models = models.map { |model| (model.instance_of?(Symbol) || model.instance_of?(String)) ? Object.const_get(model) : model }
-        crud_permissions.each do |r|
-          block.call r[:model], r[:crud] if models.index(r[:model])
-        end
+      def each_rpc(&block)
+        instance.each_rpc(&block)
+      end
+      
+      def each_crud(*models, &block)
+        instance.each_crud(*models, &block)
+      end
+      
+      private 
+      def instance
+        @instance ||= RegistryTable.new
       end
       
     end

data/lib/appbase/version.rb

@@ -1,3 +1,3 @@
 module AppBase
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appbase
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - bestmike007
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2014-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails