restricted_access 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57423d579e160bde70cb930f1afec19fd06254d0
-  data.tar.gz: af663d4ad4acf2af0484898788688e426bc1b76e
+  metadata.gz: a09963a023398671ce46a2bb029db73ec5d1ad41
+  data.tar.gz: fecea55f47f5b79637cbd1a88d178bb46328fb29
 SHA512:
-  metadata.gz: 3f05f7df578367cfeed90cff6f96be561a2547a6ab43ff283e7624239b9bdbb7c0b3697e2a1cfa854c6aa33b05b1ecf079bf00de24215671d000a6bef8e62172
-  data.tar.gz: 1d8e02118ae4acf5f2f431f431fbadc402e852547982d739777ab823eabc012b77cfa86deeb3cfb94d5754b42a62b57432ea16c90ba495e24c304f0be65c192f
+  metadata.gz: 2a0997f4e9dbe5c21eabe6bb8c9e70163721fab8e5b0d4ddce723d4b0bad94dc0ae0ec2b692993de4cdb021337d894fd54740d31ad140024df9ec1e05073201e
+  data.tar.gz: c775fc0a5e586b611b9a93fe987ef0bdde98da3bf7a0a5c2ec250192ac48f8b27130df445d84f0b432f7f98455485acf79cb35e0f88a11a955de94fd1c9d6856

data/README-v0.0.2.md

@@ -0,0 +1,178 @@
+# RestrictedAccess
+
+An access rights management tool.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'restricted_access'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install restricted_access
+
+## Usage
+
+The gem is currently working only with Mongoid.
+
+It depends on [Devise](https://github.com/plataformatec/devise) & [mongoid-enum](https://github.com/thetron/mongoid-enum).
+
+
+Generate this initializer with
+```
+rails g restricted_access:install admin --levels=mini normal super --controller_scope=backoffice
+```
+
+model_name is the name of the model concerned with the access restriction.
+
+Give the available levels of access to the --levels options
+
+Give your controllers scope name to the --controller_scope options (default: nil)
+
+This will generate the restricted_access.rb initializer
+
+```ruby
+RestrictedAccess.configure do |config|
+
+  config.accesses  = [ {  level:  :mini,
+                          label:  'Some description for this access level',
+                          power:  0 },
+                        { level: :normal,
+                          label: 'Some description for this access level',
+                          power: 1 },
+                        { level: :super,
+                          label: 'Some description for this access level',
+                          power:  2}
+                      ]
+  config.resource = :admin
+  config.controller_scope = :backoffice
+
+end
+```
+
+You can customize the accesses with a label (optional) and define different power (the higher has more rights).
+
+The `config.resource` and `config.controller_scope` are useful only in Rails, defining some methods in controllers and helpers (see below).
+
+### RestrictedAccess::Model
+
+Include the RestrictedAccess::Model module in your related model
+
+```ruby
+class Admin
+  include Mongoid::Document
+  include RestrictedAccess::Model
+
+end
+```
+
+The module enhances the model with some methods and attributes.
+
+Every model has now a :level attribute (Symbol type), by default the first defined in your initializer. You can set it like any attributes.
+
+```ruby
+admin = Admin.first
+admin.update(level: :super)
+
+admin2 = Admin.last
+admin.update(level: :mini)
+```
+
+The level defines its access rights.
+
+Each instance has a `:access` method, returning a `RestrictedAccess::Access` instance.
+
+```ruby
+admin.access
+=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @label="", @power=2>
+
+```
+
+The `RestrictedAccess::Access` class include comparable, so you can do such things :
+
+```ruby
+admin.access > admin2.access
+=> true
+
+RestrictedAccess.accesses.max
+=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @label="", @power=2>
+
+```
+
+Thanks to the [mongoid-enum](https://github.com/thetron/mongoid-enum) gem, some methods to check rights.
+
+```ruby
+admin.mini?
+=> false
+
+admin.super?
+=> true
+
+Admin::LEVEL
+=> [:mini, :normal, :super]
+
+# scopes
+Admin.mini # => Mongoid::Criteria
+Admin.super # => Mongoid::Criteria
+```
+
+### RestrictedAccess::Controller
+
+If you provided a `config.resource` and `config.controller_scope` in the initializer you can include the `RestrictedAccess::Controller` in your controller.
+
+```ruby
+class Backoffice::BaseController < ApplicationController
+  include RestrictedAccess::Controller
+end
+```
+
+Every inherited controller has now a few more methods:
+
+* `:restrict_access`, which redirect to the `#{controller_scope}_root_path`. Set controller_scope to nil if you just want to redirect to root_path.
+
+* `:prevent_#{level}_access`, which calls `:restrict_access` if the `:current_#{resource_name}` doesn't have enough access right. If you use Devise, you already have a `:current_#{resource_name}` method, if you don't use Devise, just implement it.
+
+```ruby
+class Backoffice::AdminsController < Backoffice::BaseController
+  before_action :prevent_normal_access,  except: [:index]
+  # mini & normal admins will only be able to access index view
+end
+```
+
+### RestrictedAccess::Helper
+
+```ruby
+module Backoffice::AdminHelper
+  include RestrictedAccess::Helper
+end
+```
+
+
+If you provided a `config.resource` option, you can include the `RestrictedAccess::Helper` in one of your helpers.
+
+It provides a `:available_for` method in the views, allowing you to hide some part of the view.
+
+```html
+<!-- this div won't be seen be admins lower than super -->
+<%= available_for :super do %>
+  <div>
+    I have something to hide here.
+  </div>
+<%- end %>
+```
+
+
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/restricted_access/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/README.md

@@ -6,7 +6,7 @@ An access rights management tool.
 
 Add this line to your application's Gemfile:
 
-    gem 'restricted_access', git: 'https://github.com/4nt1/restricted_access'
+    gem 'restricted_access'
 
 And then execute:
 
@@ -16,64 +16,63 @@ Or install it yourself as:
 
     $ gem install restricted_access
 
-## Usage
+## Previous version of the README (for version 0.0.2)
 
-The gem is currently working only with Mongoid.
+can be found [here](https://github.com/4nt1/restricted_access/blob/develop/README-v0.0.2.md)
 
-It depends on [Devise](https://github.com/plataformatec/devise) & [mongoid-enum](https://github.com/thetron/mongoid-enum).
+## Usage
 
+Generate the config file with the generator, pass the resources as an argument.
 
-Generate this initializer with
 ```
-rails g restricted_access:install admin --levels=mini normal super --controller_scope=backoffice
+  rails g restricted_access:install -r user admin
 ```
 
-model_name is the name of the model concerned with the access restriction.
+## Active Record
 
-Give the available levels of access to the --levels options
+You have to run a migration to add the `:level` field to your model.
 
-Give your controllers scope name to the --controller_scope options (default: nil)
-
-This will generate the restricted_access.rb initializer
+```
+$ rails g migration AddLevelToAdmin
+```
+You can edit it this way :
 
 ```ruby
-RestrictedAccess.configure do |config|
-
-  config.accesses  = [ {  level:  :mini,
-                          label:  'Some description for this access level',
-                          power:  0 },
-                        { level: :normal,
-                          label: 'Some description for this access level',
-                          power: 1 },
-                        { level: :super,
-                          label: 'Some description for this access level',
-                          power:  2}
-                      ]
-  config.resource = :admin
-  config.controller_scope = :backoffice
-
+class AddLevelToAdmins < ActiveRecord::Migration
+  def change
+    add_column :admins, :level, :integer
+  end
 end
+
 ```
 
-You can customize the accesses with a label (optional) and define different power (the higher has more rights).
+## Mongoid support
 
-The `config.resource` and `config.controller_scope` are useful only in Rails, defining some methods in controllers and helpers (see below).
+You need the [mongoid-enum](https://github.com/thetron/mongoid-enum) gem if you use mongoid.
+Just ad it to your gemfile.
 
-### RestrictedAccess::Model
+```
+gem 'mongoid-enum'
+```
+
+I didn't ship it as a dependency as it's useless for active_record users, and I didn't want to copy/paste some nice code done by someone else.
 
-Include the RestrictedAccess::Model module in your related model
+### Models
+
+You must define the different levels of accesses in your model.
 
 ```ruby
 class Admin
   include Mongoid::Document
-  include RestrictedAccess::Model
-
+  access_levels mini: 0, normal: 1, super: 2
 end
 ```
 
 The module enhances the model with some methods and attributes.
 
-Every model has now a :level attribute (Symbol type), by default the first defined in your initializer. You can set it like any attributes.
+Every model has now a :level attribute, by default the first defined by the class method.
+
+You can set it like any attributes.
 
 ```ruby
 admin = Admin.first
@@ -89,7 +88,7 @@ Each instance has a `:access` method, returning a `RestrictedAccess::Access` ins
 
 ```ruby
 admin.access
-=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @label="", @power=2>
+=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @power=2>
 
 ```
 
@@ -99,12 +98,11 @@ The `RestrictedAccess::Access` class include comparable, so you can do such thin
 admin.access > admin2.access
 => true
 
-RestrictedAccess.accesses.max
-=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @label="", @power=2>
+Admin.accesses.max
+=> #<RestrictedAccess::Access:0x007fc255d36098 @level=:super, @power=2>
 
 ```
-
-Thanks to the [mongoid-enum](https://github.com/thetron/mongoid-enum) gem, some methods to check rights.
+As the `:level` attribute is an enum, you get this kind of methods :
 
 ```ruby
 admin.mini?
@@ -113,53 +111,72 @@ admin.mini?
 admin.super?
 => true
 
-Admin::LEVEL
-=> [:mini, :normal, :super]
-
 # scopes
-Admin.mini # => Mongoid::Criteria
-Admin.super # => Mongoid::Criteria
+Admin.mini # =>     Mongoid::Criteria
+# or
+Admin.super # =>    ActiveRecord::Relation
 ```
 
-### RestrictedAccess::Controller
+### Controllers
+
+Controllers inheriting from ApplicationController have now a few more methods:
+
+* `:prevent_#{level}_#{resource_name}_access`, which calls `:restrict_#{current_resource.level}_#{resource_name}_access` if the `:current_#{resource_name}` doesn't have enough access right.
 
-If you provided a `config.resource` and `config.controller_scope` in the initializer you can include the `RestrictedAccess::Controller` in your controller.
+If you use Devise, you already have a `:current_#{resource_name}` method, if you don't use Devise, just implement the method.
 
 ```ruby
-class Backoffice::BaseController < ApplicationController
-  include RestrictedAccess::Controller
+class FrontController < ApplicationController
+  before_action :prevent_normal_admin_access,  except: [:index]
+  # mini & normal admins will only be able to access index view
 end
 ```
 
-Every inherited controller has now a few more methods:
-
-* `:restrict_access`, which redirect to the `#{controller_scope}_root_path`. Set controller_scope to nil if you just want to redirect to root_path.
+* `:restrict_#{level}_#{resource_name}_access` which redirect to the `root_path`.
 
-* `:prevent_#{level}_access`, which calls `:restrict_access` if the `:current_#{resource_name}` doesn't have enough access right. If you use Devise, you already have a `:current_#{resource_name}` method, if you don't use Devise, just implement it.
+You can override the method in your controller to do something else.
 
 ```ruby
-class Backoffice::AdminsController < Backoffice::BaseController
-  before_action :prevent_normal_access,  except: [:index]
-  # mini & normal admins will only be able to access index view
+class FrontController < ApplicationController
+  before_action :prevent_normal_admin_access,  except: [:index]
+  # Some code ...
+
+  private
+
+    def restrict_mini_admin_access
+      redirect_to some_path, notice: 'Nope dude' and return
+    end
+
+    def restrict_normal_admin_access
+      redirect_to some_other_path, notice: 'Nope dude' and return
+    end
 end
 ```
 
-### RestrictedAccess::Helper
+You can also define a more global `:restrict_#{resource_name}_access` method which applies to all concerned resources.
 
 ```ruby
-module Backoffice::AdminHelper
-  include RestrictedAccess::Helper
+class FrontController < ApplicationController
+
+  private
+    # this method as a bigger precedency than the other one
+    def restrict_admin_access
+      redirect_to some_path, notice: 'Nope dude' and return
+    end
+
+    def restrict_normal_admin_access
+      redirect_to some_other_path, notice: 'Nope dude' and return
+    end
 end
 ```
 
+### Helpers
 
-If you provided a `config.resource` option, you can include the `RestrictedAccess::Helper` in one of your helpers.
-
-It provides a `:available_for` method in the views, allowing you to hide some part of the view.
+The gem provides a `:available_for` method in the views, allowing you to hide some part of the view.
 
 ```html
 <!-- this div won't be seen be admins lower than super -->
-<%= available_for :super do %>
+<%= available_for :super, :admin do %>
   <div>
     I have something to hide here.
   </div>
@@ -171,7 +188,7 @@ It provides a `:available_for` method in the views, allowing you to hide some pa
 
 ## Contributing
 
-1. Fork it ( http://github.com/<my-github-username>/restricted_access/fork )
+1. Fork it ( http://github.com/4nt1/restricted_access/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/generators/restricted_access/USAGE

@@ -3,7 +3,7 @@ Description:
     Generate the initializer.
 
 Example:
-    rails g restricted_access:install admin --levels=mini super mega --controller_scope=backoffice
+    rails g restricted_access:install
 
     This will create:
         app/config/initializers/restricted_access.rb

data/lib/generators/restricted_access/install_generator.rb

@@ -1,19 +1,14 @@
+require 'rails/generators/base'
+require 'securerandom'
 module RestrictedAccess
   module Generators
-    class InstallGenerator < Rails::Generators::NamedBase
-      include Rails::Generators::ResourceHelpers
+    class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path('../templates', __FILE__)
-      argument      :resource_name,     type: :string,  default: 'user'
-      class_option  :levels,            type: :array,   default: ['normal', 'super'],   desc: "List of the differents access levels"
-      class_option  :controller_scope,  type: :string,                                  desc: "Scope of the concerned controllers"
 
       desc "Creates a RestrictedAccess initializer."
+      class_option :orm
 
-      def set_variable
-        @levels           = options.levels
-        @resource_name    = resource_name
-        @controller_scope = options.controller_scope
-      end
+      class_option  :resources,            type: :array,   desc: "List of the differents resources", aliases: '-r'
 
       def copy_initializer
         template "restricted_access.erb", "config/initializers/restricted_access.rb"

data/lib/generators/restricted_access/templates/restricted_access.erb

@@ -1,18 +1,4 @@
-RestrictedAccess.configure do |config|
-
-  config.accesses = [<% @levels.each_with_index do |level, index| %>
-                    { level:  :<%= level %>,
-                      label:  '',
-                      power:  <%= index %> }<% if index + 1 < @levels.count %>,<%- end %>
-                  <%- end %>
-                  ]
-
-  config.resource = :<%= @resource_name %>
-
-<% if @controller_scope %>
-  config.controller_scope = :<%= @controller_scope %>
-<% else %>
-config.controller_scope = nil
-<%- end %>
-
+RestrictedAccess.configure do |conf|
+  require 'restricted_access/orm/<%= options[:orm] %>'
+  conf.resources = <%= options[:resources].map { |r| r.downcase.singularize.to_sym } %>
 end

data/lib/restricted_access.rb

@@ -1,9 +1,7 @@
-require "mongoid/enum"
 require "restricted_access/version"
 require 'restricted_access/configuration'
 require 'restricted_access/access'
-require 'restricted_access/model'
-require 'restricted_access/controller'
+require 'restricted_access/models'
 require 'restricted_access/helper'
 
 module RestrictedAccess
@@ -15,41 +13,14 @@ module RestrictedAccess
 
     def configure
       yield(configuration)
-      define_dynamic_methods
+      require 'restricted_access/controller'
+      ActionController::Base.send(:include, RestrictedAccess::Controller)
+      ActionView::Base.send(:include, RestrictedAccess::Helper)
     end
 
-    def accesses
-      @accesses ||= configuration.accesses.map do |a|
-        Access.new(a[:level], a[:label], a[:power])
-      end
+    def resources
+      @resources ||= configuration.resources
     end
 
-    def resource
-      @resource ||= configuration.resource
-    end
-
-    def controller_scope
-      @controller_scope ||= configuration.controller_scope
-    end
-
-    def define_dynamic_methods
-      # on Access class
-      accesses.map(&:level).each do |level|
-        Access.define_singleton_method level do
-          RestrictedAccess.accesses.find {|a| a.level == level}
-        end
-
-        RestrictedAccess::Controller.class_eval do
-          define_method "prevent_#{level}_access" do
-            restrict_access if send("current_#{RestrictedAccess.resource}").access <= RestrictedAccess::Access.send(level)
-          end
-
-          define_method :restrict_access do
-            _scope = RestrictedAccess.controller_scope.present? ? "#{RestrictedAccess.controller_scope}_" : nil
-            redirect_to send("#{_scope}root_path"), notice: 'You do not have access to this page' and return
-          end
-        end
-      end
-    end
   end
 end

data/lib/restricted_access/access.rb

@@ -1,15 +1,14 @@
 module RestrictedAccess
   class Access
     include Comparable
-    attr_accessor :level, :label, :power
+    attr_accessor :level, :power
 
     def <=>(access)
       power <=> access.power
     end
 
-    def initialize(level, label, power)
+    def initialize(level, power)
       @level = level
-      @label = label
       @power = power
     end
 

data/lib/restricted_access/configuration.rb

@@ -1,7 +1,5 @@
 module RestrictedAccess
   class Configuration
-    attr_accessor :accesses
-    attr_accessor :resource
-    attr_accessor :controller_scope
+    attr_accessor :resources
   end
 end

data/lib/restricted_access/controller.rb

@@ -1,6 +1,30 @@
 module RestrictedAccess
   module Controller
 
-  end
+    RestrictedAccess.resources.each do |resource_name|
+      klass = resource_name.to_s.classify.constantize
+      if klass.accesses.present?
+        klass.accesses.each do |access|
+
+          define_method "prevent_#{access.level}_#{resource_name}_access" do
+            current_resource = send("current_#{resource_name}")
+            if current_resource && current_resource.access <= klass.send(:access, access.level)
+              if respond_to?("restrict_#{resource_name}_access", true)
+                send("restrict_#{resource_name}_access")
+              else
+                send("restrict_#{current_resource.level}_#{resource_name}_access"
+                  )
+              end
+            end
+          end
+
+          define_method "restrict_#{access.level}_#{resource_name}_access" do
+            redirect_to root_path, notice: 'You do not have access to this page' and return
+          end
+        end
+      end
 
+    end
+
+  end
 end

data/lib/restricted_access/helper.rb

@@ -1,8 +1,9 @@
 module RestrictedAccess
   module Helper
-    def available_for(level, &block)
-      access = RestrictedAccess::Access.send(level)
-      capture(&block) if access && send("current_#{RestrictedAccess.resource}") && send("current_#{RestrictedAccess.resource}").access >= access
+    def available_for(level, resource_name, &block)
+      klass   = resource_name.to_s.classify.constantize
+      access  = klass.send(level)
+      capture(&block) if access && send("current_#{resource_name}") && send("current_#{resource_name}").access >= access
     end
   end
 end

data/lib/restricted_access/models.rb

@@ -0,0 +1,37 @@
+module RestrictedAccess
+  module Models
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      attr_reader :accesses
+
+      def access_levels(accesses)
+        @accesses = accesses.map { |k, v| Access.new(k, v) }
+
+        # define level store field
+        if defined?(Mongoid::Document)
+          enum :level, accesses.keys
+        elsif defined?(ActiveRecord::Base)
+          enum level: accesses
+        else
+          raise 'Your ORM is not recognized.'
+        end
+
+      end
+
+      def access(level_name)
+        @accesses.find { |a| a.level == level_name }
+      end
+    end
+
+    def access
+      self.class.access(level.to_sym)
+    end
+
+    def authorized_accesses
+      self.class.accesses.select { |a| a <= access }
+    end
+
+  end
+end

data/lib/restricted_access/orm/active_record.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+
+ActiveRecord::Base.extend RestrictedAccess::Models::ClassMethods
+ActiveRecord::Base.include RestrictedAccess::Models

data/lib/restricted_access/orm/mongoid.rb

@@ -0,0 +1,6 @@
+require 'mongoid'
+require "mongoid/enum"
+
+Mongoid::Document::ClassMethods.send :include, RestrictedAccess::Models::ClassMethods
+Mongoid::Document.send :include, RestrictedAccess::Models
+Mongoid::Document.send :include, Mongoid::Enum

data/lib/restricted_access/version.rb

@@ -1,3 +1,3 @@
 module RestrictedAccess
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/restricted_access.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = RestrictedAccess::VERSION
   spec.authors       = ["4nt1"]
   spec.email         = ["antoinemary@hotmail.fr"]
-  spec.summary       = %q{An access rights management tool intended to work with Devise}
-  spec.description   = %q{An access rights management tool intended to work with Devise}
+  spec.summary       = %q{An access rights management tool}
+  spec.description   = %q{An access rights management tool. Define routes and part of views that can be accessed by resources.}
   spec.homepage      = "https://github.com/4nt1/restricted_access"
   spec.license       = "MIT"
 
@@ -19,7 +19,4 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_dependency "mongoid"
-  spec.add_dependency "mongoid-enum"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restricted_access
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - 4nt1
@@ -24,49 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: rake
-  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: mongoid
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mongoid-enum
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: An access rights management tool intended to work with Devise
+description: An access rights management tool. Define routes and part of views that
+  can be accessed by resources.
 email:
 - antoinemary@hotmail.fr
 executables: []
@@ -76,6 +35,7 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
+- README-v0.0.2.md
 - README.md
 - Rakefile
 - lib/generators/restricted_access/USAGE
@@ -86,7 +46,9 @@ files:
 - lib/restricted_access/configuration.rb
 - lib/restricted_access/controller.rb
 - lib/restricted_access/helper.rb
-- lib/restricted_access/model.rb
+- lib/restricted_access/models.rb
+- lib/restricted_access/orm/active_record.rb
+- lib/restricted_access/orm/mongoid.rb
 - lib/restricted_access/version.rb
 - restricted_access.gemspec
 homepage: https://github.com/4nt1/restricted_access
@@ -112,5 +74,5 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: An access rights management tool intended to work with Devise
+summary: An access rights management tool
 test_files: []

data/lib/restricted_access/model.rb

@@ -1,19 +0,0 @@
-module RestrictedAccess
-  module Model
-    extend ActiveSupport::Concern
-
-    included do |base|
-      include Mongoid::Enum
-      enum :level,                    RestrictedAccess.accesses.map(&:level)
-    end
-
-    def access
-      RestrictedAccess.accesses.find {|a| a.level == level}
-    end
-
-    def authorized_accesses
-      RestrictedAccess.accesses.select {|a| a <= access}
-    end
-
-  end
-end