appbase 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21e5c0b2f097283d8f398c5ca323f8a68c1a3f8a
+  data.tar.gz: 8b9a0d23b5942695c3e34b1afce107208d0d2a38
+SHA512:
+  metadata.gz: b05fb2ef0b47302f41b5f6740a152251975b4ad451acc5d7755aa6b2695830ffee91639af82c6e7accc6f964786f6b9afe7b996289f3aacbd8e152e75f251519
+  data.tar.gz: 0cea345d69931905d64301d26a69137332d8213978857b3ab05a63c7453cb0a0e4fd06d29bd66569862459b8f7f1f4a2b182c3ff559d7b29b3a65dbd0ad74e88

data/lib/appbase/controllers/app_base_controller.rb

@@ -0,0 +1,165 @@
+class AppBaseController < ActionController::Base
+  
+  def version
+    render json: AppBase::VERSION
+  end
+  
+  def current_user
+    nil
+  end
+  
+  class << self
+    
+    def define_useridentity(user_identity, token_store, token_key_user, token_key_session)
+      self.class_eval %-
+        def current_user(options={})
+          if #{token_store}[:#{token_key_user}].nil? || #{token_store}[:#{token_key_session}].nil?
+            return options[:default] if options.has_key? :default
+            raise "unauthenticated"
+          end
+          #{user_identity}.authenticate_by_token(#{token_store}[:#{token_key_user}], #{token_store}[:#{token_key_session}])
+        end
+      -
+    end
+    
+    def add_create_stub(model)
+      m = model.name
+      permits = model.columns.map { |item| item.name }.to_json
+      self.module_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
+        rescue Exception => e
+          render json: { status: 'error', msg: e.to_s }
+        end
+      -
+    end
+    
+    def add_update_stub(model)
+      m = model.name
+      permits = model.columns.map { |item| item.name }.to_json
+      self.module_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
+      -
+    end
+    
+    def add_delete_stub(model)
+      m = model.name
+      self.module_eval %-
+        def delete_#{AppBase.underscore m}
+          obj = #{m}.find(params[:id])
+          if obj.nil?
+            return render json: { status: 'error', msg: 'not_found' }
+          end
+          if !#{m}.allow_delete?(current_user, obj)
+            render json: { status: "error", msg: "unauthorized" }
+          else
+            obj.delete
+            render json: { status: 'ok' }
+          end
+        rescue Exception => e
+          render json: { status: 'error', msg: e.to_s }
+        end
+      -
+    end
+    
+    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)
+          params.except(:action, :controller, :p, :ps).each { |k, v|
+            op = 'eq'
+            if k.index('.') && k.split('.').count == 2
+              k, op = k.split('.')
+            end
+            return if #{columns}.index(k).nil?
+            case op
+            when 'eq'
+              query = query.where "\#{k} = ?", v
+            when 'lt'
+              query = query.where "\#{k} < ?", v
+            when 'le'
+              query = query.where "\#{k} <= ?", v
+            when 'gt'
+              query = query.where "\#{k} > ?", v
+            when 'ge'
+              query = query.where "\#{k} >= ?", v
+            when 'n'
+              query = query.where "\#{k} IS NULL"
+            when 'nn'
+              query = query.where "\#{k} IS NOT NULL"
+            when 'in'
+              values = JSON.parse v
+              query = query.where "\#{k} IN (?)", values
+            when 'nin'
+              values = JSON.parse v
+              query = query.where "\#{k} NOT IN (?)", values
+            else
+            end
+          }
+          page_size = [1, (params[:ps]||20).to_i].max
+          start = [0, (params[:p]||1).to_i.pred].max * page_size
+          render json: { status: 'ok', data: query.offset(start).limit(page_size) }
+        rescue Exception => e
+          render json: { status: 'error', msg: e.to_s }
+        end
+      -
+    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, atuh: false` to expose #{m}.#{mn} to appbase without user authentication."
+      end
+      need_params = false
+      if parameters.last[0] == :opt
+        need_params = true
+        parameters = parameters[(auth ? 1 : 0)..-2]
+      else
+        parameters = parameters[(auth ? 1 : 0)..-1]
+      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!"
+      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(', ')}" : ""})"
+      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 }
+        end
+      -
+    end
+    
+  end
+  
+end

data/lib/appbase/model_concern.rb

@@ -0,0 +1,108 @@
+require 'active_support'
+
+module AppBase
+  
+  module ModelConcern
+  
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      
+      def expose_to_appbase(*method_names)
+        return if method_names.count == 0
+        options = {}
+        if method_names.last.instance_of? Hash
+          *method_names, options = method_names
+        end
+        method_names.each do |method_name|
+          AppBase::Registry.register_rpc self, method_name, options
+        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)
+        self.appbase_allow(:create, criteria, &block)
+      end
+      
+      def allow_update(criteria=:mine, &block)
+        self.appbase_allow(:update, criteria, &block)
+      end
+      
+      def allow_delete(criteria=:mine, &block)
+        self.appbase_allow(:delete, criteria, &block)
+      end
+      
+      def allow_query(criteria=:mine, &block)
+        self.appbase_allow(:query, criteria, &block)
+      end
+      
+    end
+    
+  end
+  
+end
+
+ActiveRecord::Base.include AppBase::ModelConcern

data/lib/appbase/railtie.rb

@@ -0,0 +1,126 @@
+require 'rails'
+require_relative "registry"
+require_relative "model_concern"
+require_relative "controllers/app_base_controller"
+
+module AppBase
+  
+  class Engine < Rails::Engine
+    
+    paths["app/controllers"] = "lib/appbase/controllers"
+    
+    class << self
+      
+      initialized = false
+      config = nil
+      hooks = []
+      
+      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
+          else
+            raise "Unexpected crud operation: #{op}"
+          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]}."
+          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]}"
+          end
+        end
+        
+        # finalize appbase routes
+        AppBase::Engine.routes.draw do
+          get "/appbase_version" => "app_base#version"
+        end
+        
+        # after initialized
+        blocks, hooks = hooks, []
+        blocks.each do |block|
+          block.call
+        end
+        
+      end
+      
+      define_method :after_initialized do |&block|
+        if initialized
+          block.call
+        else
+          hooks << block
+        end
+      end
+      
+      define_method :config do
+        config
+      end
+      
+    end
+    
+  end
+
+  class Railtie < Rails::Railtie
+
+    # default values for appbase configuration
+    config.appbase = ActiveSupport::OrderedOptions.new
+    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|
+      
+      AppBase::Engine.bootstrap app.config
+      
+      app.routes.append do
+        mount AppBase::Engine => Rails.application.config.appbase.mount
+      end
+      
+    end
+    
+  end
+
+end

data/lib/appbase/registry.rb

@@ -0,0 +1,60 @@
+module AppBase
+  
+  def self.underscore(str)
+    str.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+  module StringExtension
+    
+    def underscore
+      AppBase.underscore self
+    end
+    self
+    
+  end
+  
+  module Registry
+    
+    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"
+        end
+      end
+      
+      define_method :each_rpc do |&block|
+        rpc_methods.each &block
+      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
+      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
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/appbase/version.rb

@@ -0,0 +1,3 @@
+module AppBase
+  VERSION = '0.0.1'
+end

data/lib/appbase.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.dirname(__FILE__))
+
+require_relative 'appbase/railtie' if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: appbase
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- bestmike007
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A lightweight backend for Web/iOS/Android apps.
+email: i@bestmike007.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/appbase.rb
+- lib/appbase/controllers/app_base_controller.rb
+- lib/appbase/model_concern.rb
+- lib/appbase/railtie.rb
+- lib/appbase/registry.rb
+- lib/appbase/version.rb
+homepage: http://bestmike007.com/appbase
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Lightweight appbase
+test_files: []