appbase 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21e5c0b2f097283d8f398c5ca323f8a68c1a3f8a
-  data.tar.gz: 8b9a0d23b5942695c3e34b1afce107208d0d2a38
+  metadata.gz: 4287ccf943cbb1549e3524e7e20d676f0bc1fc16
+  data.tar.gz: 91a967f151ead8e747170cc8e4129162b2b4d7ff
 SHA512:
-  metadata.gz: b05fb2ef0b47302f41b5f6740a152251975b4ad451acc5d7755aa6b2695830ffee91639af82c6e7accc6f964786f6b9afe7b996289f3aacbd8e152e75f251519
-  data.tar.gz: 0cea345d69931905d64301d26a69137332d8213978857b3ab05a63c7453cb0a0e4fd06d29bd66569862459b8f7f1f4a2b182c3ff559d7b29b3a65dbd0ad74e88
+  metadata.gz: d5c3719f395cd41c315df6ae9af9efd9f8e683af7ed464eb9aa903d999e19d224cad5f9a84c859feac49f543589965ac6e258cb2c5d60e2bbaf1562c0a051ff1
+  data.tar.gz: 10597b8d9d43506240431a9f6e89b886e073841c90363c69cf7e26c5336dd080f5ac656e8f5380582f268f4794c6d732bf4db3476be107a1a912a7892f6f20e4

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mike He
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,257 @@
+[![Build Status](https://travis-ci.org/bestmike007/appbase.svg?branch=master)](https://travis-ci.org/bestmike007/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.
+
+What is appbase? Appbase is a lightweight backend based on rails for rubyists with the following basic features:
+
++ User registration and authentication
++ REST model crud api
++ Expose business logic with a simple line of code
++ 3rd party authentication
++ Push notifications
++ Payment integration
++ Other basic features mostly required by apps
+
+Appbase is/does not:
+
++ Use GUI to configure models and/or business logic
++ Use configuration files
+
+Appbase is under development; and will be kept as simple as possible.
+
+## Basic Usage
+
+Configure in `application.rb`:
+
+``` ruby
+  # enable appbase
+  config.appbase.enabled = true
+  # default: '/appbase'
+  # config.appbase.mount = "/_api"
+  config.appbase.user_identity = :User # required
+  config.appbase.token_store = :cookies # :cookies, :headers, :params
+  config.appbase.token_key_user = :u
+  config.appbase.token_key_session = :s
+  config.appbase.models.push :User, :Role, :Permission, :UserProfile, :TodoItem, :GroupTodoList
+```
+
+Implement `UserIdentityModel#authenticate_by_token(user, token)`:
+
+``` ruby
+  class User < ActiveRecord::Base
+    def self.authenticate_by_token(user, token)
+      # TODO cache the result
+      User.find_by(user: user, token: token)
+    end
+  end
+```
+
+Set up CRUD permissions for models:
+
+``` ruby
+  class TodoItem < ActiveRecord::Base
+  
+    # Allow query
+    allow_query :mine
+    # or
+    allow_query :within => :related_to_me
+    def self.related_to_me(current_user)
+      TodoItem.where user_id: current_user.id
+    end
+    # or
+    allow_query :within do |current_user|
+      TodoItem.where user_id: current_user.id
+    end
+    
+    # Allow create/update/delete
+    allow_create :mine
+    # or
+    allow_update :if => :related_to_me?
+    def self.related_to_me?(current_user, obj)
+      obj.user_id == current_user.id
+    end
+    # or
+    allow_delete :if do |current_user, obj|
+      obj.user_id == current_user.id
+    end
+    
+    # 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]
+    restrict_query_columns only: [:updated_at, :created_at]
+    
+    # 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
+    restrict_query_operators :updated_at, :created_at, except: :in
+    
+  end
+```
+
+Expose business logic methods:
+
+``` ruby
+  
+  # don't have to be an active record
+  class GroupTodoList
+  
+    include AppBase::ModelConcern
+    
+    expose_to_appbase :list_group_todos, auth: true # default to true
+    
+    def self.list_group_todos(current_user)
+      TodoItem.find_all group_id: current_user.group_id
+    end
+    
+  end
+  
+  # public methods, e.g. authentication, does not have the `current_user` parameter
+  class User < ActiveRecord::Base
+    
+    expose_to_appbase :authenticate, :external_auth, auth: false
+    
+    def self.authenticate(user, pass)
+      user = User.find_by username: user, password: pass
+      return nil if user.nil?
+      user.last_login = Time.now
+      user.session_token = SecureRandom.hex
+      user.save!
+      user.session_token
+    end
+    
+    def self.external_auth(user, options={})
+      case options[:provider]
+      when 'twitter'
+        # do authenticate
+      when 'facebook'
+        # do authenticate
+      else
+        raise "unsupported provider"
+      end
+    end
+    
+  end
+```
+
+And that's all. 
+
+## The Request Scheme
+
+Apps (including iOS app, Andriod app, web app with angularjs or similar frontend framework, etc.) are communicating with appbase using HTTP/HTTPS.
+
+### The REST API
+
+Basic CRUD api conforms to the representational state transfer (REST) architectural style. Following sections are using model `Note (id, title, content)` as an example to illustrate how a model is created, updated, deleted, and how to perform a query on a model (Supose that the appbase engine is mount on `/_api`).
+
+#### Create
+
+Request to create a model with JSON serialized body:
+
+```
+PUT /_api/note HTTP/1.1
+HOST xxx
+Content-Type: application/json
+
+{ "title" : "test" , "content" : "hello", "user_id" : 1 }
+```
+
+The server response on success:
+
+```
+HTTP/1.1 200 OK
+
+{"status":"ok","id":1}
+```
+
+On failure:
+
+```
+HTTP/1.1 200 OK
+
+{"status":"error","msg":"error_msg"}
+```
+
+#### Update
+
+Almost the same as create except for adding the `:id` parameter (e.g. `/_api/note/:id`):
+
+```
+PUT /_api/note/1 HTTP/1.1
+HOST xxx
+Content-Type: application/json
+
+{ "title" : "test" , "content" : "hello appabse!", "user_id" : 1 }
+```
+
+#### Delete
+
+```
+DELETE /_api/note/1 HTTP/1.1
+HOST xxx
+```
+
+#### Query
+
+The request:
+
+```
+GET /_api/note?p=1&ps=20 HTTP/1.1
+HOST xxx
+```
+
+In the parameters, `p` indicates the page of the query; `ps` indicates the page size of the query. Except for the pagination parameters, query parameters are allowed to filter the query. Supose we need to perform a query on `Note.id`, here are some examples on how to query:
+
++ /_api/note?p=1&ps=20`&id=1` Equal to 1
++ /_api/note?p=1&ps=20`&id.lt=10` Less than 10
++ /_api/note?p=1&ps=20`&id.le=10` Less than or equal to 10
++ /_api/note?p=1&ps=20`&id.gt=1` Greater than 1
++ /_api/note?p=1&ps=20`&id.ge=1` Greater than or equal to 1
++ /_api/note?p=1&ps=20`&id.lt=10&id.ge=1` Greater than or equal to 1 and less than 10
++ /_api/note?p=1&ps=20`&id.in=[1,2,3]` In 1, 2, 3
++ /_api/note?p=1&ps=20`&id.nin=[1,2,3]` Not in 1, 2, 3
++ /_api/note?p=1&ps=20`&id.n=true` Is null
++ /_api/note?p=1&ps=20`&id.nn=true` Not null
+
+`OR` conditions are not supported for now, use exposed methods instead.
+
+### RPC Methods
+
+Model methods with custom business logic can be exposed as rpc methods, take the method `Note.related_to_me(current_user, limit)` as example.
+
+```
+POST /_api/note/related_to_me HTTP/1.1
+HOST xxx
+
+limit=10
+```
+
+Response from the backend should be:
+
+```
+HTTP/1.1 200 OK
+
+{"status":"ok","data":[{"id":1,"key":"value"},{"id":2,"key":"value"},{"id":3,"key":"value"}]}
+```
+
+If the method is defined with an `options` parameter, e.g. `Note.related_to_me(current_user, options={})`, then optional request arguments are passed to the method within the option hash object.
+
+## Known Issues
+
++ `OR` conditions are not supported for active record query
++ Multiple accessible query base
++ Write more test cases
++ Complete the document
+
+You're welcome to contribute to this project by creating an issue / a pull request.
+
+---
+
+## License
+
+Appbase is released under the [MIT License](http://opensource.org/licenses/MIT).

data/appbase.gemspec

@@ -0,0 +1,17 @@
+require File.expand_path('../lib/appbase/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'appbase'
+  s.version     = AppBase::VERSION
+  s.summary     = "Lightweight appbase"
+  s.description = "A lightweight backend for Web/iOS/Android apps."
+  s.authors     = ["bestmike007"]
+  s.email       = 'i@bestmike007.com'
+  s.homepage    = 'http://bestmike007.com/appbase'
+  s.license     = 'MIT'
+  s.files       = Dir['lib/**/*'] + ['LICENSE', 'README.md', 'appbase.gemspec']
+  
+  s.required_ruby_version = '>= 1.9.0'
+  s.add_runtime_dependency 'rails', '>= 4.0', '< 4.2'
+  s.add_development_dependency "rspec-rails", "~> 3.1", '>= 3.1.0'
+end

data/lib/appbase/controllers/app_base_controller.rb

@@ -17,7 +17,12 @@ class AppBaseController < ActionController::Base
             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}])
+          user = #{user_identity}.authenticate_by_token(#{token_store}[:#{token_key_user}], #{token_store}[:#{token_key_session}])
+          if user.nil?
+            return options[:default] if options.has_key? :default
+            raise "unauthenticated"
+          end
+          user
         end
       -
     end
@@ -25,7 +30,7 @@ class AppBaseController < ActionController::Base
     def add_create_stub(model)
       m = model.name
       permits = model.columns.map { |item| item.name }.to_json
-      self.module_eval %-
+      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)
@@ -43,7 +48,7 @@ class AppBaseController < ActionController::Base
     def add_update_stub(model)
       m = model.name
       permits = model.columns.map { |item| item.name }.to_json
-      self.module_eval %-
+      self.class_eval %-
         def update_#{AppBase.underscore m}
           obj = #{m}.find(params[:id])
           if obj.nil?
@@ -64,7 +69,7 @@ class AppBaseController < ActionController::Base
     
     def add_delete_stub(model)
       m = model.name
-      self.module_eval %-
+      self.class_eval %-
         def delete_#{AppBase.underscore m}
           obj = #{m}.find(params[:id])
           if obj.nil?
@@ -90,32 +95,40 @@ class AppBaseController < ActionController::Base
           query = #{m}.accessible_by(current_user)
           params.except(:action, :controller, :p, :ps).each { |k, v|
             op = 'eq'
+            k = k.to_s
             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
+            k = k.to_sym
+            operators = #{m}.appbase_queryable_operators[k]
+            unless #{m}.appbase_queryable_columns.index(k).nil?
+              case op
+              when 'eq'
+                query = query.where "\#{k} = ?", v if operators.nil? || !operators.index(:equal).nil?
+              when 'lt'
+                query = query.where "\#{k} < ?", v if operators.nil? || !operators.index(:compare).nil?
+              when 'le'
+                query = query.where "\#{k} <= ?", v if operators.nil? || !operators.index(:compare).nil?
+              when 'gt'
+                query = query.where "\#{k} > ?", v if operators.nil? || !operators.index(:compare).nil?
+              when 'ge'
+                query = query.where "\#{k} >= ?", v if operators.nil? || !operators.index(:compare).nil?
+              when 'n'
+                query = query.where "\#{k} IS NULL" if operators.nil? || !operators.index(:equal).nil?
+              when 'nn'
+                query = query.where "\#{k} IS NOT NULL" if operators.nil? || !operators.index(:equal).nil?
+              when 'in'
+                if operators.nil? || !operators.index(:in).nil?
+                  values = JSON.parse v
+                  query = query.where "\#{k} IN (?)", values
+                end
+              when 'nin'
+                if operators.nil? || !operators.index(:in).nil?
+                  values = JSON.parse v
+                  query = query.where "\#{k} NOT IN (?)", values
+                end
+              else
+              end
             end
           }
           page_size = [1, (params[:ps]||20).to_i].max
@@ -132,10 +145,10 @@ class AppBaseController < ActionController::Base
       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."
+        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."
       end
       need_params = false
-      if parameters.last[0] == :opt
+      if parameters.count > 0 && parameters.last[0] == :opt
         need_params = true
         parameters = parameters[(auth ? 1 : 0)..-2]
       else

data/lib/appbase/model_concern.rb

@@ -84,25 +84,112 @@ module AppBase
       end
       
       def allow_create(criteria=:mine, &block)
-        self.appbase_allow(:create, criteria, &block)
+        appbase_allow(:create, criteria, &block)
       end
       
       def allow_update(criteria=:mine, &block)
-        self.appbase_allow(:update, criteria, &block)
+        appbase_allow(:update, criteria, &block)
       end
       
       def allow_delete(criteria=:mine, &block)
-        self.appbase_allow(:delete, criteria, &block)
+        appbase_allow(:delete, criteria, &block)
       end
       
       def allow_query(criteria=:mine, &block)
-        self.appbase_allow(:query, criteria, &block)
+        appbase_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)
+        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
+        
+        self.define_singleton_method :appbase_queryable_columns do
+          columns
+        end
+        
+      end
+      
+      def appbase_queryable_operators
+        return {}
+      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)
+        *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
+        
+        columns.each do |c|
+          operators[c.to_sym] = set
+        end
+        
+        self.define_singleton_method :appbase_queryable_operators do
+          operators
+        end
+        
+      end
+      
+      
     end
     
   end
   
 end
 
-ActiveRecord::Base.include AppBase::ModelConcern
+class ActiveRecord::Base
+  include AppBase::ModelConcern
+end

data/lib/appbase/railtie.rb

@@ -81,6 +81,7 @@ module AppBase
         blocks.each do |block|
           block.call
         end
+        initialized = true
         
       end
       
@@ -104,6 +105,7 @@ module 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
@@ -113,10 +115,16 @@ module AppBase
     
     initializer "appbase.configure_route", :after => :add_routing_paths do |app|
       
-      AppBase::Engine.bootstrap app.config
+      if File.basename(ENV['_']) == 'rake'
+        puts "Running with `rake #{$*.join(' ')}`"
+      end
       
-      app.routes.append do
-        mount AppBase::Engine => Rails.application.config.appbase.mount
+      if config.appbase.enabled && (File.basename(ENV['_']) != 'rake' || $*[0] == 'routes')
+        AppBase::Engine.bootstrap app.config
+        
+        app.routes.append do
+          mount AppBase::Engine => Rails.application.config.appbase.mount
+        end
       end
       
     end

data/lib/appbase/registry.rb

@@ -19,6 +19,8 @@ module AppBase
   
   module Registry
     
+    # rpc & crud methods registration
+    # used once upon rails startup, cannot be reloaded by spring.
     class << Registry
       
       rpc_methods = []

data/lib/appbase/version.rb

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

metadata

@@ -1,91 +1,64 @@
 --- !ruby/object:Gem::Specification
 name: appbase
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - bestmike007
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-17 00:00:00.000000000 Z
+date: 2014-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.2'
   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
+        version: '4.2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-rails
   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:
-    - - "~>"
+        version: '3.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.1.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:
-    - - "~>"
+        version: '3.1'
+    - - ">="
       - !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'
+        version: 3.1.0
 description: A lightweight backend for Web/iOS/Android apps.
 email: i@bestmike007.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
+- appbase.gemspec
 - lib/appbase.rb
 - lib/appbase/controllers/app_base_controller.rb
 - lib/appbase/model_concern.rb
@@ -104,7 +77,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="