rolify 3.0.0 → 3.1.0

data/CHANGELOG.rdoc

@@ -1,4 +1,16 @@
-= 3.0 (unreleased)
+= 3.1 (Apr 6, 2012)
+* Mongoid adapter optimization
+* adapter code refactoring
+* generator now adds the role class name to the rolify method injected in the user class
+* fixed a bug on the generator when using a 2 words Camel case for the Role class name
+* <b>DEPRECATION NOTICE:</b> <tt>has_role</tt> and <tt>has_no_role</tt> have been depecrated. They are replaced by <tt>add_role</tt> and <tt>remove_role</tt>
+* some internals cleanup (backward compatible)
+* stop requiring <tt>active_record</tt> in <tt>rolify.rb</tt> to prevent other gems ORM detection issue
+* fixed a bug when removing a role to the user using Mongoid adapter
+* added indexes to generator for mongoid (thanks to @stigi)
+* fixed a bug regarding **with_role** method on resource classes (thanks to @nfo)
+
+= 3.0 (Apr 2, 2012)
 * support for Mongoid
 * roles search on resources on instance level (e.g. <tt>Forum.first.roles</tt>) and class level (e.g. <tt>Forum.with_role("admin", user)</tt>)
 * heavy lifting and redesign of the library, code and specs refactoring

data/{README.rdoc → README.md}

@@ -1,138 +1,166 @@
-= rolify {<img src="https://secure.travis-ci.org/EppO/rolify.png?branch=master">}[http://travis-ci.org/EppO/rolify] {<img src="https://gemnasium.com/EppO/rolify.png">}[https://gemnasium.com/EppO/rolify]
+# rolify [![build status](https://secure.travis-ci.org/EppO/rolify.png?branch=master)](http://travis-ci.org/EppO/rolify) [![dependency status](https://gemnasium.com/EppO/rolify.png)](https://gemnasium.com/EppO/rolify)
 
 Very simple Roles library without any authorization enforcement supporting scope on resource object.
 
-Let's see an example:  
+Let's see an example: 
 
-  user.has_role?("moderator", Forum.first) 
-  => false # if user is moderator of another Forum
+```ruby
+user.has_role?(:moderator, Forum.first) 
+=> false # if user is moderator of another Forum
+```
 
-This library was intended to be used with CanCan[https://github.com/ryanb/cancan] and devise[https://github.com/plataformatec/devise/] but should be generic enough to be used by any other authentication/authorization solutions.
+This library was intended to be used with [CanCan](https://github.com/ryanb/cancan) and [devise](https://github.com/plataformatec/devise) but should be generic enough to be used by any other authentication/authorization solutions.
 
-== Requirements
+## Requirements
 
 * >= Rails 3.1
 * ActiveRecord ORM <b>or</b> Mongoid
 * supports ruby 1.8/1.9, REE, JRuby and Rubinius
 
-== Installation
+## Installation
 
 In <b>Rails 3</b>, add this to your Gemfile and run the +bundle+ command.
 
+```ruby
   gem "rolify"
+```
 
 Alternatively, you can install it as a plugin.
 
+```
   rails plugin install git://github.com/EppO/rolify.git
+```
 
-== Getting Started
+## Getting Started
 
-=== 1. Generate Role Model
+### 1. Generate Role Model
 
 First, create your Role model and migration file using this generator:
 
+```
   rails g rolify:role Role User
+```
 
 Role and User classes are the default. You can specify any Role class name you want. This is completly a new file so any name can do the job.
 For the User class name, you would probably use the one provided by your authentication solution. rolify just adds some class methods in an existing User class.
 
-If you want to use Mongoid instead of ActiveRecord, follow these instructions[https://github.com/EppO/rolify/wiki/Configuration], and skip to step #3
+If you want to use Mongoid instead of ActiveRecord, follow these [instructions](https://github.com/EppO/rolify/wiki/Configuration), and skip to step #3
 
-=== 2. Run the migration (only required when using ActiveRecord)
+### 2. Run the migration (only required when using ActiveRecord)
 
 Let's migrate !
 
+```
   rake db:migrate
+```
 
-=== 3. Add a role to a user
+### 3. Add a role to a user
 
 To define a global role:
 
+```ruby
   user = User.find(1)
-  user.has_role "admin"
+  user.add_role :admin
+```
 
 To define a role scoped to a resource instance
 
+```ruby
   user = User.find(2)
-  user.has_role "moderator", Forum.first
+  user.add_role :moderator, Forum.first
+```
 
 To define a role scoped to a resource class
 
+```ruby
   user = User.find(3)
-  user.has_role "moderator", Forum
+  user.add_role :moderator, Forum
+```
 
 That's it !
 
-=== 4. Check roles
+### 4. Check roles
 
 To check if a user has a global role: 
 
+```ruby
   user = User.find(1)
-  user.has_role "admin" # sets a global role
-  user.has_role? "admin"
+  user.add_role :admin # sets a global role
+  user.has_role? :admin
   => true
+```
 
 To check if a user has a role scoped to a resource instance:
 
+```ruby
   user = User.find(2)
-  user.has_role "moderator", Forum.first # sets a role scoped to a resource instance
-  user.has_role? "moderator", Forum.first
+  user.add_role :moderator, Forum.first # sets a role scoped to a resource instance
+  user.has_role? :moderator, Forum.first
   => true
-  user.has_role? "moderator", Forum.last
+  user.has_role? :moderator, Forum.last
   => false
+```
 
 To check if a user has a role scoped to a resource class:
 
+```ruby
   user = User.find(3)
-  user.has_role "moderator", Forum # sets a role scoped to a resource class
-  user.has_role? "moderator", Forum
+  user.add_role :moderator, Forum # sets a role scoped to a resource class
+  user.has_role? :moderator, Forum
   => true
-  user.has_role? "moderator", Forum.first
+  user.has_role? :moderator, Forum.first
   => true
-  user.has_role? "moderator", Forum.last
+  user.has_role? :moderator, Forum.last
   => true
+```
 
 A global role overrides resource role request: 
 
+```ruby
   user = User.find(4)
-  user.has_role "moderator" # sets a global role
-  user.has_role? "moderator", Forum.first
+  user.add_role :moderator # sets a global role
+  user.has_role? :moderator, Forum.first
   => true
-  user.has_role? "moderator", Forum.last
+  user.has_role? :moderator, Forum.last
   => true
+```
 
-=== 5. Resource roles querying 
+### 5. Resource roles querying 
 
 Starting from rolify 3.0, you can search roles on instance level or class level resources.
 
-==== Instance level
+#### Instance level
 
+```ruby
   forum = Forum.first
   forum.roles
   # => [ list of roles that are only binded to forum instance ]
   forum.applied_roles
   # => [ list of roles binded to forum instance and to the Forum class ]
+```
 
-==== Class level
+#### Class level
 
-  Forum.with_role("admin")
+```ruby
+  Forum.with_role(:admin)
   # => [ list of Forum instances that has role "admin" binded to it ] 
-  Forum.with_role("admin", current_user)
+  Forum.with_role(:admin, current_user)
   # => [ list of Forum instances that has role "admin" binded to it and belongs to current_user roles ]
   
   Forum.find_roles
   # => [ list of roles that binded to any Forum instance or to the Forum class ]
-  Forum.find_roles("admin")
+  Forum.find_roles(:admin)
   # => [ list of roles that binded to any Forum instance or to the Forum class with "admin" as a role name ]
-  Forum.find_roles("admin", current_user)
+  Forum.find_roles(:admin, current_user)
   # => [ list of roles that binded to any Forum instance or to the Forum class with "admin" as a role name and belongs to current_user roles ]
+```
 
-== Resources
+## Resources
 
-* {Wiki}[https://github.com/EppO/rolify/wiki]
-* {Usage}[https://github.com/EppO/rolify/wiki/Usage]: all the available commands
-* {Tutorial}[https://github.com/EppO/rolify/wiki/Tutorial]: how to use {rolify}[http://eppo.github.com/rolify] with {Devise}[https://github.com/plataformatec/devise] and {CanCan}[https://github.com/ryanb/cancan].
+* [Wiki](https://github.com/EppO/rolify/wiki)
+* [Usage](https://github.com/EppO/rolify/wiki/Usage): all the available commands
+* [Tutorial](https://github.com/EppO/rolify/wiki/Tutorial): how to use [rolify](http://eppo.github.com/rolify) with [Devise](https://github.com/plataformatec/devise) and [CanCan](https://github.com/ryanb/cancan).
 
-== Questions or Problems?
+## Questions or Problems?
 
-If you have any issue or feature request with/for rolify, please add an {issue on GitHub}[https://github.com/EppO/rolify/issues] or fork the project and send a pull request.
+If you have any issue or feature request with/for rolify, please add an [issue on GitHub](https://github.com/EppO/rolify/issues) or fork the project and send a pull request.

data/lib/generators/rolify/role/role_generator.rb

@@ -14,9 +14,9 @@ module Rolify
       desc "Generates a model with the given NAME and a migration file."
 
       def generate_role
-        template "role-#{orm_adapter}.rb", "app/models/#{role_cname.downcase}.rb"
+        template "role-#{orm_adapter}.rb", "app/models/#{role_cname.underscore}.rb"
         inject_into_class(model_path, user_cname.camelize) do
-          "\trolify\n"
+          "\trolify" + (role_cname == "Role" ? "" : ":role_cname => '#{role_cname.camelize}'") + "\n"
         end
       end
 

data/lib/generators/rolify/role/templates/initializer.rb

@@ -1,7 +1,7 @@
-Rolify.configure do |c|
+Rolify.configure do |config|
   # By default ORM adapter is ActiveRecord. uncomment to use mongoid
-  <%= "# " if orm_adapter == "active_record" %>c.use_mongoid
+  <%= "# " if orm_adapter == "active_record" %>config.use_mongoid
   
   # Dynamic shortcuts for User class (user.is_admin? like methods). Default is: false
-  <%= "# " if !options[:dynamic_shortcuts] %>c.use_dynamic_shortcuts
+  <%= "# " if !options[:dynamic_shortcuts] %>config.use_dynamic_shortcuts
 end

data/lib/generators/rolify/role/templates/role-mongoid.rb

@@ -5,4 +5,13 @@ class <%= role_cname.camelize %>
   belongs_to :resource, :polymorphic => true
   
   field :name, :type => String
+  index :name, unique: true
+  index(
+    [
+      [:name, Mongo::ASCENDING],
+      [:resource_type, Mongo::ASCENDING],
+      [:resource_id, Mongo::ASCENDING]
+    ],
+    unique: true
+  )
 end

data/lib/rolify.rb

@@ -1,36 +1,39 @@
-require 'active_record'
-
-require 'rolify/adapters/active_record' if defined?(ActiveRecord)
-require 'rolify/adapters/mongoid' if defined?(Mongoid)
 require 'rolify/railtie' if defined?(Rails)
+require 'rolify/utils'
 require 'rolify/role'
 require 'rolify/configure'
 require 'rolify/dynamic'
 require 'rolify/resource'
+require 'rolify/adapters/base'
 
 module Rolify
   extend Configure
+
   attr_accessor :role_cname, :adapter
 
   def rolify(options = { :role_cname => 'Role' })
     include Role
     extend Dynamic if Rolify.dynamic_shortcuts
+    
     rolify_options = { :class_name => options[:role_cname].camelize }
     rolify_options.merge!({ :join_table => "#{self.to_s.tableize}_#{options[:role_cname].tableize}" }) if Rolify.orm == "active_record"
     has_and_belongs_to_many :roles, rolify_options
 
-    load_dynamic_methods if Rolify.dynamic_shortcuts
+    self.adapter = Rolify::Adapter::Base.create("role_adapter", options[:role_cname], self.name)
     self.role_cname = options[:role_cname]
-    self.adapter = Rolify::Adapter.const_get(Rolify.orm.camelize).new(options[:role_cname])
+    
+    load_dynamic_methods if Rolify.dynamic_shortcuts
   end
 
   def resourcify(options = { :role_cname => 'Role' })
     include Resource
+    
     resourcify_options = { :class_name => options[:role_cname].camelize }
     resourcify_options.merge!({ :as => :resource })
     has_many :roles, resourcify_options
+    
+    self.adapter = Rolify::Adapter::Base.create("resource_adapter", options[:role_cname], self.name)
     self.role_cname = options[:role_cname]
-    self.adapter = Rolify::Adapter.const_get(Rolify.orm.camelize).new(options[:role_cname])
   end
   
   def role_class

data/lib/rolify/adapters/active_record/resource_adapter.rb

@@ -0,0 +1,17 @@
+require 'rolify/adapters/base'
+
+module Rolify
+  module Adapter   
+    class ResourceAdapter < ResourceAdapterBase
+      def resources_find(roles_table, relation, role_name)
+        resources = relation.joins("INNER JOIN \"#{roles_table}\" ON \"#{roles_table}\".\"resource_type\" = '#{relation.to_s}'")
+        resources = resources.where("#{roles_table}.name = ? AND #{roles_table}.resource_type = ?", role_name, relation.to_s)
+        resources
+      end
+
+      def in(relation, roles)
+        relation.where("#{role_class.to_s.tableize}.id IN (?) AND ((resource_id = #{relation.table_name}.id) OR (resource_id IS NULL))", roles)
+      end
+    end
+  end
+end

data/lib/rolify/adapters/{active_record.rb → active_record/role_adapter.rb}

@@ -2,13 +2,8 @@ require 'rolify/adapters/base'
 
 module Rolify
   module Adapter   
-    class ActiveRecord < Adapter::Base    
-      def find(relation, role_name, resource)
-        query, values = build_query(role_name, resource)
-        relation.where(query, *values)
-      end
-
-      def where(relation, args)
+    class RoleAdapter < RoleAdapterBase
+      def where(relation, *args)
         conditions, values = build_conditions(relation, args)
         relation.where(conditions, *values)
       end
@@ -22,20 +17,16 @@ module Rolify
       end
 
       def remove(relation, role_name, resource = nil)
-        role = relation.where(:name => role_name)
-        role = role.where(:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)) if resource
-        role = role.where(:resource_id => resource.id) if resource && !resource.is_a?(Class)
-        relation.delete(role) if role
-      end
-
-      def resources_find(roles_table, relation, role_name)
-        resources = relation.joins("INNER JOIN \"#{roles_table}\" ON \"#{roles_table}\".\"resource_type\" = '#{relation.to_s}'")
-        resources = resources.where("#{roles_table}.name = ? AND #{roles_table}.resource_type = ?", role_name, relation.to_s)
-        resources
-      end
-
-      def in(relation, roles)
-        relation.where("#{role_class.to_s.tableize}.id IN (?) AND ((resource_id = #{relation.table_name}.id) OR (resource_id IS NULL))", roles)
+        roles = relation.roles.where(:name => role_name)
+        roles = roles.where(:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)) if resource
+        roles = roles.where(:resource_id => resource.id) if resource && !resource.is_a?(Class)
+        if roles
+          relation.roles.delete(roles)
+          roles.each do |role| 
+            role.destroy if role.send(user_class.table_name.to_sym).empty? 
+          end
+        end
+        roles
       end
 
       def exists?(relation, column)

data/lib/rolify/adapters/base.rb

@@ -1,52 +1,54 @@
 module Rolify
   module Adapter
     class Base
-      def initialize(role_cname)
+      def initialize(role_cname, user_cname)
         @role_cname = role_cname
+        @user_cname = user_cname
       end
-      
+
       def role_class
         @role_cname.constantize
       end
       
-      def find(relation, role_name, resource)
-        raise NotImplementedError.new("You must implement find")
+      def user_class
+        @user_cname.constantize
       end
       
+      def self.create(adapter, role_cname, user_cname)
+        load "rolify/adapters/#{Rolify.orm}/#{adapter}.rb"
+        Rolify::Adapter.const_get(adapter.camelize.to_sym).new(role_cname, user_cname)
+      end
+    end
+
+    class RoleAdapterBase < Adapter::Base
       def where(relation, args)
         raise NotImplementedError.new("You must implement where")
       end
-      
+
       def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
         raise NotImplementedError.new("You must implement find_or_create_by")
       end
-      
+
       def add(relation, role_name, resource = nil)
         raise NotImplementedError.new("You must implement add")
       end
-      
+
       def remove(relation, role_name, resource = nil)
         raise NotImplementedError.new("You must implement delete")
       end
-      
-      def resources_find(roles_table, relation, role_name)
-       raise NotImplementedError.new("You must implement resources_find")
-      end
-      
-      def in(resources, roles)
-        raise NotImplementedError.new("You must implement in")
-      end
-      
+
       def exists?(relation, column)
         raise NotImplementedError.new("You must implement exists?")
       end
-      
-      def build_conditions(relation, args)
-        raise NotImplementedError.new("You must implement build_conditions")
+    end
+
+    class ResourceAdapterBase < Adapter::Base
+      def resources_find(roles_table, relation, role_name)
+        raise NotImplementedError.new("You must implement resources_find")
       end
-      
-      def build_query(role, resource = nil)
-        raise NotImplementedError.new("You must implement build_query")
+
+      def in(resources, roles)
+        raise NotImplementedError.new("You must implement in")
       end
     end
   end