rolify 1.0.0 → 1.1.0

data/CHANGELOG.rdoc

@@ -1,4 +1,18 @@
-= 1.0
+= 1.1 (Oct 14, 2011)
+* added a spec to test the rails generator using ammeter gem
+* Gemfile cleanup, moved all dependencies in gemspec instead
+* edited the dependency to Rails 3.1 and newer, now that Rails 3.1 has been released
+* new role scoping capabilities
+  * instance level : <tt>user.has_role "moderator", Forum.first</tt> (<em>already supported in previous release</em>). user has the moderator role only on that Forum in particular
+  * class level : <tt>user.has_role "moderator", Forum</tt>. User has the moderator role on all instances of Forum
+  * global level : <tt>user.has_role "moderator"</tt> (<em>already supported in previous release</em>). User has the moderator role globally (e.q. on all resources)
+* new scoped query capabilities
+  * <tt>user.has_role? "moderator", Forum.first</tt> (<em>already supported in previous release</em>). asks if the user has the moderator role on Forum.first instance
+  * <tt>user.has_role? "moderator", Forum</tt>. asks if the user has the moderator role on all Forum instances
+  * <tt>user.has_role? "moderator"</tt> (<em>already supported in previous release</em>). asks if the user has the global moderator role
+  * <tt>user.has_role? "moderator", :any</tt>. asks if the user has at least one moderator role no matter the scope is (instance, class or global).
+
+= 1.0 (Aug 25, 2011)
 * added a new parameter to disable dynamic shortcut methods due to potential incompatibility with other gems using method_missing with the same pattern
   * add <tt>Rolify.dynamic_shortcuts = false</tt> in the initializer file or 
   * use the generator command with a third parameter: 
@@ -7,26 +21,26 @@
 * code refactoring to do some speed improvements and code clean up
 * added a lot of specs to improve tests coverage
 * wrote a tutorial showing how to use rolify with CanCan and Devise
-* rolify is now on travis-ci
+* rolify is now on travis-ci to monitor build status
 
-= 0.7
+= 0.7 (June 20, 2011)
 * added a method_missing to catch newly created role outside the current ruby process (i.e. dynamic shortcut methods are not defined within this process) 
   * dynamic shortcut is created on the fly in the method_missing to avoid extra method_missing for the same dynamic shortcut 
   * check if the role actually exists in the database before defining the new method 
   * first call is slower due to method_missing but next calls are fast
   * avoid strange bugs when spawning many ruby processes as the dynamic shortcut methods were only defined in the process that used the <tt>has_role</tt> command
 
-= 0.6
+= 0.6 (June 19, 2011)
 * custom User and Role class names support
   * can now use other class names for Role and User classes
   * fixed generators and templates 
   * join table is explicitly set to avoid alphabetical order issue
 * created a new railtie to load the dynamic shortcuts at startup
 
-= 0.5.1
-* fixed a nasty typo on a variable name and added a spec to make this never happen again
+= 0.5.1 (June 07, 2011)
+* fixed a nasty typo on a variable name and added a spec to make it never happen again
 
-= 0.5
+= 0.5 (June 07, 2011)
 * dynamic shortcuts support
   * creates automatically new methods upon new role creation (or at startup for a Rails app)
   * <tt>has_role "admin"</tt> will create a method called <tt>is_admin?</tt>
@@ -34,21 +48,21 @@
      * <tt>is_moderator_of?(resource)</tt>
      * <tt>is_moderator?</tt>
 
-= v0.4
+= v0.4 (June 07, 2011)
 * removing role support
   * <tt>has_no_role</tt> removes a global role or a role scoped to a resource
   * Please note that trying to remove a global role whereas the user a role with the same name on a resource will remove that scoped role
   * Trying to remove a role scoped to a resource whereas the user has a global role won't remove it
 
-= v0.3
+= v0.3 (June 06, 2011)
 * multiple roles check: 
   * <tt>has_all_roles?</tt> returns true if the user has ALL the roles in arguments
   * <tt>has_any_role?</tt> returns true if the user has ANY the roles in arguments
 
-= v0.2
+= v0.2 (June 04, 2011)
 * fixed the generator to include the lib
 * fixed the migration file with missing polymorphic field
 * added some examples in documentation
 
-= v0.1
+= v0.1 (June 04, 2011)
 * first release

data/Gemfile

@@ -1,12 +1,4 @@
 source "http://rubygems.org"
 
-gem "activerecord", :require => "active_record"
-
 # Specify your gem's dependencies in rolify.gemspec
 gemspec
-
-group :test do
-  gem "sqlite3"
-  gem "rspec"
-  gem "rake"
-end

data/README.rdoc

@@ -1,4 +1,4 @@
-= rolify http://travis-ci.org/EppO/rolify.png
+= rolify {<img src="https://secure.travis-ci.org/EppO/rolify.png">}[http://travis-ci.org/EppO/rolify]
 Very simple Roles library without any authorization enforcement supporting scope on resource object.
 
 Let's see an example:  
@@ -10,7 +10,7 @@ This library was intended to be used with CanCan[https://github.com/ryanb/cancan
 
 == Requirements
 
-* >= Rails 3.1 (rc4 is currently out)
+* >= Rails 3.1
 * ActiveRecord ORM
 
 == Installation
@@ -47,11 +47,16 @@ To define a global role:
   user = User.find(1)
   user.has_role "admin"
 
-To define a role scoped to a resource
+To define a role scoped to a resource instance
 
   user = User.find(2)
   user.has_role "moderator", Forum.first
 
+To define a role scoped to a resource class
+
+  user = User.find(3)
+  user.has_role "moderator", Forum
+
 That's it !
 
 === 4. Check roles
@@ -63,18 +68,29 @@ To check if a user has a global role:
   user.has_role? "admin"
   => true
 
-To check if a user has a role scoped to a resource:
+To check if a user has a role scoped to a resource instance:
 
   user = User.find(2)
-  user.has_role "moderator", Forum.first # sets a role scoped to a resource
+  user.has_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
   => false
 
-A global role overrides resource role request: 
+To check if a user has a role scoped to a resource class:
 
   user = User.find(3)
+  user.has_role "moderator", Forum # sets a role scoped to a resource class
+  user.has_role? "moderator", Forum
+  => true
+  user.has_role? "moderator", Forum.first
+  => true
+  user.has_role? "moderator", Forum.last
+  => true
+
+A global role overrides resource role request: 
+
+  user = User.find(4)
   user.has_role "moderator" # sets a global role
   user.has_role? "moderator", Forum.first
   => true
@@ -85,9 +101,4 @@ Please see on {the wiki}[https://github.com/EppO/rolify/wiki/Usage] for all the
 
 == 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.
-
-== TODO
-
-* complete tests coverage
-* performance enhancements
+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/rolify/role.rb

@@ -28,9 +28,9 @@ module Rolify
   module Roles
 
     def has_role(role_name, resource = nil)
-      role = Rolify.role_cname.find_or_create_by_name_and_resource_type_and_resource_id( :name => role_name, 
-                                                                                  :resource_type => (resource.class.name if resource), 
-                                                                                  :resource_id => (resource.id if resource))
+      role = Rolify.role_cname.find_or_create_by_name_and_resource_type_and_resource_id(:name => role_name, 
+                                                                                        :resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
+                                                                                        :resource_id => (resource.id if resource && !resource.is_a?(Class)))
       if !roles.include?(role)
         self.class.define_dynamic_method(role_name, resource) if Rolify.dynamic_shortcuts
         self.roles << role
@@ -62,8 +62,8 @@ module Rolify
   
     def has_no_role(role_name, resource = nil)
       role = self.roles.where( :name => role_name)
-      role = role.where( :resource_type => resource.class.name,
-                         :resource_id => resource.id) if resource
+      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)
       self.roles.delete(role) if role
     end
   
@@ -102,12 +102,18 @@ module Rolify
     end
 
     def build_query(role, resource = nil)
+      return [ "name = ?", role] if resource == :any
       query = "((name = ?) AND (resource_type IS NULL) AND (resource_id IS NULL))"
       values = [ role ]
       if resource
         query.insert(0, "(")
-        query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id = ?)))" 
-        values << role << resource.class.name << resource.id
+        query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id IS NULL))" 
+        values << role << (resource.is_a?(Class) ? resource.to_s : resource.class.name)
+        if !resource.is_a? Class
+          query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id = ?))" 
+          values << role << resource.class.name << resource.id
+        end
+        query += ")"
       end
       [ [ query ], values]
     end
@@ -135,4 +141,4 @@ module Rolify
       end
     end    
   end
-end
+end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/rolify.gemspec

@@ -19,6 +19,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
+  s.add_dependency "activerecord", ">= 3.1.0"
+  
   s.add_development_dependency "sqlite3"
-  s.add_dependency "activerecord", "~> 3.1.0.rc1"
+  s.add_development_dependency "ammeter"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "bundler" 
 end

data/spec/generators/rolify/role/role_generator_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+# Generators are not automatically loaded by Rails
+require 'generators/rolify/role/role_generator'
+
+describe Rolify::Generators::RoleGenerator do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../../tmp", __FILE__)
+  before { 
+    prepare_destination
+  }
+
+  describe 'no arguments' do
+    before(:all) { arguments [] }
+
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+          "class User < ActiveRecord::Base\nend"
+        end
+      }
+      run_generator 
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.user_cname = User" }
+      it { should contain "Rolify.role_cname = Role" }
+      it { should contain "Rolify.dynamic_shortcuts = true" }
+    end
+    
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain "include Rolify::Roles" }
+      it { should contain "extend Rolify::Reloaded" }
+      it { should contain "has_and_belongs_to_many :roles, :join_table => :users_roles" }
+    end
+    
+    describe 'migration file' do
+      subject { file('db/migrate/rolify_create_roles.rb') }
+      
+      # should be_a_migration - verifies the file exists with a migration timestamp as part of the filename 
+      it { should be_a_migration }
+    end
+  end
+
+  describe 'specifying user and role names' do
+    before(:all) { arguments %w(Rank Client) }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/client.rb" do
+          "class Client < ActiveRecord::Base\nend"
+        end
+      }
+      run_generator
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.user_cname = Client" }
+      it { should contain "Rolify.role_cname = Rank" }
+      it { should contain "Rolify.dynamic_shortcuts = true" }
+    end
+    
+    describe 'app/models/client.rb' do
+      subject { file('app/models/client.rb') }
+      it { should contain "include Rolify::Roles" }
+      it { should contain "extend Rolify::Reloaded" }
+      it { should contain "has_and_belongs_to_many :roles, :class_name => \"Rank\", :join_table => :clients_ranks" }
+    end
+    
+    describe 'migration file' do
+      subject { file('db/migrate/rolify_create_ranks.rb') }
+      
+      # should be_a_migration - verifies the file exists with a migration timestamp as part of the filename 
+      it { should be_a_migration }
+      #it { should contain "create_table(:ranks)" }
+    end
+  end
+  
+  describe 'specifying no dynamic shortcuts' do
+    before(:all) { arguments [ "Role", "User", "--no-dynamic_shortcuts" ] }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+          "class User < ActiveRecord::Base\nend"
+        end
+      }
+      run_generator
+    }
+      
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.dynamic_shortcuts = false" }
+    end
+    
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain "include Rolify::Roles" }
+      it { should_not contain "extend Rolify::Reloaded" }
+      it { should contain "has_and_belongs_to_many :roles, :join_table => :users_roles" }
+    end
+    
+    describe 'migration file' do
+      subject { file('db/migrate/rolify_create_roles.rb') }
+      
+      # should be_a_migration - verifies the file exists with a migration timestamp as part of the filename 
+      it { should be_a_migration }
+    end
+  end
+end

data/spec/rolify/role_spec.rb

@@ -1,262 +1,419 @@
 require "spec_helper"
 
 shared_examples_for "Rolify module" do |dynamic|
-    context "in a Instance level" do 
-      before(:all) do
-        Rolify.user_cname = user_cname
-        Rolify.role_cname = role_cname
-        Rolify.dynamic_shortcuts = dynamic_shortcuts
-        Rolify.role_cname.destroy_all
-        @admin = Rolify.user_cname.first
-        @admin.has_role "admin"
-        @admin.has_role "moderator", Forum.first
-      end
-
-      it "should respond to has_role method" do 
-        @admin.should respond_to(:has_role).with(1).arguments
-        @admin.should respond_to(:has_role).with(2).arguments
-      end
-
-      it "should respond to has_role? method" do
-        @admin.should respond_to(:has_role?).with(1).arguments
-        @admin.should respond_to(:has_role?).with(2).arguments
-      end
-
-      it "should respond to has_all_roles? method" do
-        @admin.should respond_to(:has_all_roles?)
-        @admin.should respond_to(:has_all_roles?)
-      end
-
-      it "should respond to has_any_role? method" do
-        @admin.should respond_to(:has_any_role?)
-        @admin.should respond_to(:has_any_role?)
-      end
-    
-      it "should respond to has_no_role method" do
-        @admin.should respond_to(:has_no_role).with(1).arguments
-        @admin.should respond_to(:has_no_role).with(2).arguments
-      end
-
-      it "should respond to dynamic methods", :if => dynamic do
-        @admin.should respond_to(:is_admin?).with(0).arguments
-        @admin.should respond_to(:is_moderator_of?).with(1).arguments
-      end
-
-      it "should not respond to any unknown methods", :if => dynamic do
-        @admin.should_not respond_to(:is_god?)
-      end
-
-      it "should create a new dynamic method if role exists in database", :if => dynamic do 
-        Rolify.role_cname.create(:name => "superman")
-        @admin.should respond_to(:is_superman?).with(0).arguments
-        @admin.is_superman?.should be(false)
-        Rolify.role_cname.create(:name => "batman", :resource => Forum.first)
-        @admin.should respond_to(:is_batman_of?).with(1).arguments
-        @admin.should respond_to(:is_batman?).with(0).arguments
-        @admin.is_batman_of?(Forum.first).should be(false)
-      end
-
-      it "should not have any dynamic methods if dynamic_shortcuts is disabled", :if => dynamic == false do
-        @admin.should_not respond_to(:is_admin?)
-        @admin.should_not respond_to(:is_moderator_of?)
-      end
-    end
-
-    context "with a global role" do 
-      before(:all) do
-        @admin = Rolify.user_cname.first
-        @admin.has_role "admin"
-        @admin.has_role "staff"
-        @admin.has_role "moderator", Forum.first
-      end
-    
-      it "should set a global role" do
-        expect { @admin.has_role "superadmin" }.to change{ Rolify.role_cname.count }.by(1)
-        superadmin = Rolify.role_cname.last
-        superadmin.name.should eq("superadmin")
-        superadmin.resource.should be(nil)
-      end
-    
-      it "should not create another role if already existing" do
-        expect { @admin.has_role "admin" }.not_to change{ Rolify.role_cname.count }
-        expect { @admin.has_role "admin" }.not_to change{ @admin.roles.size }
-      end
-    
-      it "should get a global role" do
-        @admin.has_role?("admin").should be(true)
-      end
+  before(:all) do
+    Rolify.user_cname = user_cname
+    Rolify.role_cname = role_cname
+    Rolify.dynamic_shortcuts = dynamic_shortcuts
+    Rolify.role_cname.destroy_all
+  end
+  
+  context "in a Instance level" do 
+    before(:all) do
+      @admin = Rolify.user_cname.first
+      @admin.has_role "admin"
+      @admin.has_role "moderator", Forum.first
+    end
 
-      it "should be able to use dynamic shortcut", :if => dynamic do
-        @admin.is_admin?.should be(true)
-      end
-    
-      it "should get any resource request" do
-        @admin.has_role?("admin", Forum.first).should be(true)
-      end
-    
-      it "should not get another global role" do
-        Rolify.role_cname.create(:name => "global")
-        @admin.has_role?("global").should be(false)
-      end
-    
-      it "should not get a scoped role" do
-        @admin.has_role?("moderator", Forum.last).should be(false)
-      end
-    
-      it "should not get inexisting role" do
-        @admin.has_role?("dummy").should be(false)
-        @admin.has_role?("dumber", Forum.first).should be(false)
-      end
-
-      it "should check if user has all of a global roles set" do
-        @admin.has_all_roles?("staff").should be(true)
-        @admin.has_all_roles?("admin", "staff").should be(true)
-        @admin.has_all_roles?("admin", "dummy").should be(false)
-        @admin.has_all_roles?("dummy", "dumber").should be(false)
-      end
-
-      it "should check if user has any of a global roles set" do
-        @admin.has_any_role?("staff").should be(true)
-        @admin.has_any_role?("admin", "staff").should be(true)
-        @admin.has_any_role?("admin", "moderator").should be(true)
-        @admin.has_any_role?("dummy", "dumber").should be(false)
-      end
-    
-      it "should remove a global role of a user" do 
-        expect { @admin.has_no_role("admin") }.to change{ @admin.roles.size }.by(-1)
-        @admin.has_role?("admin").should be(false)
-        @admin.has_role?("staff").should be(true)
-        @admin.has_role?("moderator", Forum.first).should be(true)
-      end
-    
-      it "should remove a scoped role of a user" do
-        expect { @admin.has_no_role("moderator") }.to change{ @admin.roles.size }.by(-1)
-        @admin.has_role?("staff").should be(true)
-        @admin.has_role?("moderator", Forum.first).should be(false)
-      end
-    
-      it "should not remove a another global role" do 
-        expect { @admin.has_no_role("global") }.not_to change{ @admin.roles.size }
-      end
+    it "should respond to has_role method" do 
+      @admin.should respond_to(:has_role).with(1).arguments
+      @admin.should respond_to(:has_role).with(2).arguments
     end
-  
-    context "with a scoped role" do
-      before(:all) do
-        @moderator = Rolify.user_cname.find(2)
-        @moderator.has_role "moderator", Forum.first
-        @moderator.has_role "soldier"
-      end
-      
-      it "should set a scoped role" do
-        expect { @moderator.has_role "visitor", Forum.last }.to change{ Rolify.role_cname.count }.by(1)
-        supermodo = Rolify.role_cname.last
-        supermodo.name.should eq("visitor")
-        supermodo.resource.should eq(Forum.last)
-      end
-    
-      it "should not create another role if already existing" do
-        expect { @moderator.has_role "moderator", Forum.first }.not_to change{ Rolify.role_cname.count }
-        expect { @moderator.has_role "moderator" , Forum.first }.not_to change{ @moderator.roles.size }
-      end
-    
-      it "should get a scoped role" do
-        @moderator.has_role?("moderator", Forum.first).should be(true)
-      end
-
-      it "should be able to use dynamic shortcut", :if => dynamic do
-        @moderator.is_moderator?.should be(false)
-        @moderator.is_moderator_of?(Forum.first).should be(true)
-        @moderator.is_moderator_of?(Forum.last).should be(false)
-      end
-
-      it "should not get a global role" do
-        @moderator.has_role?("admin").should be(false)
-      end
-    
-      it "should not get the same role on another resource" do
-        Rolify.role_cname.create(:name => "moderator", :resource => Forum.last)
-        @moderator.has_role?("moderator", Forum.last).should be(false)
-      end
-      
-      it "should not get the another role on the same resource" do
-        Rolify.role_cname.create(:name => "tourist", :resource => Forum.first)
-        @moderator.has_role?("tourist", Forum.first).should be(false)
-      end
-    
-      it "should not get inexisting role" do
-        @moderator.has_role?("dummy", Forum.last).should be(false)
-        @moderator.has_role?("dumber").should be(false)
-      end
-    
-      it "should check if user has all of a scoped roles set" do
-        @moderator.has_all_roles?({ :name => "visitor", :resource => Forum.last }).should be(true)
-        @moderator.has_all_roles?({ :name => "moderator", :resource => Forum.first }, 
-                                  { :name => "visitor", :resource => Forum.last }).should be(true)
-        @moderator.has_all_roles?({ :name => "moderator", :resource => Forum.first }, 
-                                  { :name => "dummy", :resource => Forum.last }).should be(false)
-        @moderator.has_all_roles?({ :name => "dummy", :resource => Forum.first }, 
-                                  { :name => "dumber", :resource => Forum.last }).should be(false)
-      end
-
-      it "should check if user has any of a scoped roles set" do
-        @moderator.has_any_role?( { :name => "visitor", :resource => Forum.last }).should be(true)
-        @moderator.has_any_role?( { :name => "moderator", :resource => Forum.first }, 
-                                  { :name => "visitor", :resource => Forum.last }).should be(true)
-        @moderator.has_any_role?( { :name => "moderator", :resource => Forum.first }, 
-                                  { :name => "dummy", :resource => Forum.last }).should be(true)
-        @moderator.has_any_role?( { :name => "dummy", :resource => Forum.first }, 
-                                  { :name => "dumber", :resource => Forum.last }).should be(false)
-      end
-    
-      it "should not remove a global role of a user" do 
-        expect { @moderator.has_no_role("soldier", Forum.first) }.not_to change{ @moderator.roles.size }
-      end
-    
-      it "should remove a scoped role of a user" do 
-        expect { @moderator.has_no_role("moderator", Forum.first) }.to change{ @moderator.roles.size }.by(-1)
-        @moderator.has_role?("moderator", Forum.first).should be(false)
-        @moderator.has_role?("soldier").should be(true)
-      end
-    
-      it "should not remove another scoped role" do
-        expect { @moderator.has_no_role("visitor", Forum.first) }.not_to change{ @moderator.roles.size }
-      end
+
+    it "should respond to has_role? method" do
+      @admin.should respond_to(:has_role?).with(1).arguments
+      @admin.should respond_to(:has_role?).with(2).arguments
+    end
+
+    it "should respond to has_all_roles? method" do
+      @admin.should respond_to(:has_all_roles?)
+      @admin.should respond_to(:has_all_roles?)
+    end
+
+    it "should respond to has_any_role? method" do
+      @admin.should respond_to(:has_any_role?)
+      @admin.should respond_to(:has_any_role?)
+    end
+
+    it "should respond to has_no_role method" do
+      @admin.should respond_to(:has_no_role).with(1).arguments
+      @admin.should respond_to(:has_no_role).with(2).arguments
+    end
+
+    it "should respond to dynamic methods", :if => dynamic do
+      @admin.should respond_to(:is_admin?).with(0).arguments
+      @admin.should respond_to(:is_moderator_of?).with(1).arguments
+    end
+
+    it "should not respond to any unknown methods", :if => dynamic do
+      @admin.should_not respond_to(:is_god?)
+    end
+
+    it "should create a new dynamic method if role exists in database", :if => dynamic do 
+      Rolify.role_cname.create(:name => "superman")
+      @admin.should respond_to(:is_superman?).with(0).arguments
+      Rolify.role_cname.create(:name => "batman", :resource => Forum.first)
+      @admin.should respond_to(:is_batman_of?).with(1).arguments
+      @admin.should respond_to(:is_batman?).with(0).arguments
+    end
+
+    it "should not have any dynamic methods if dynamic_shortcuts is disabled", :if => dynamic == false do
+      @admin.should_not respond_to(:is_admin?)
+      @admin.should_not respond_to(:is_moderator_of?)
+    end
+  end
+
+  context "with a global role" do 
+    before do
+      @admin = Rolify.user_cname.first
+      @admin.has_role "admin"
+      @admin.has_role "staff"
+      @admin.has_role "moderator", Forum.first
+      @admin.has_role "moderator", Forum.find(2)
+      @admin.has_role "manager", Group
+    end
+
+    it "should set a global role" do
+      expect { @admin.has_role "superadmin" }.to change{ Rolify.role_cname.count }.by(1)
+      superadmin = Rolify.role_cname.last
+      superadmin.name.should eq("superadmin")
+      superadmin.resource.should be(nil)
+    end
+
+    it "should not create another role if already existing" do
+      expect { @admin.has_role "admin" }.not_to change{ Rolify.role_cname.count }
+      expect { @admin.has_role "admin" }.not_to change{ @admin.roles.size }
+    end
+
+    it "should get a global role" do
+      @admin.has_role?("admin").should be(true)
+    end
+
+    it "should be able to use dynamic shortcut", :if => dynamic do
+      @admin.is_admin?.should be(true)
+      @admin.is_evil?.should be(false)
+    end
+
+    it "should get any resource request" do
+      @admin.has_role?("admin", Forum.first).should be(true)
+      @admin.has_role?("admin", Forum).should be(true)
+      @admin.has_role?("admin", :any).should be(true)
+    end
+
+    it "should not get another global role" do
+      Rolify.role_cname.create(:name => "global")
+      @admin.has_role?("global").should be(false)
+      @admin.has_role?("global", :any).should be(false)
+    end
+
+    it "should not get an instance scoped role" do
+      @admin.has_role?("moderator", Forum.last).should be(false)
+    end
+
+    it "should not get a class scoped role" do
+      @admin.has_role?("manager", Forum).should be(false)
+    end
+
+    it "should not get inexisting role" do
+      @admin.has_role?("dummy").should be(false)
+      @admin.has_role?("dumber", Forum.first).should be(false)
+    end
+
+    it "should check if user has all of a global roles set" do
+      @admin.has_all_roles?("staff").should be(true)
+      @admin.has_all_roles?("admin", "staff").should be(true)
+      @admin.has_all_roles?("admin", "dummy").should be(false)
+      @admin.has_all_roles?("dummy", "dumber").should be(false)
+    end
+
+    it "should check if user has any of a global roles set" do
+      @admin.has_any_role?("staff").should be(true)
+      @admin.has_any_role?("admin", "staff").should be(true)
+      @admin.has_any_role?("admin", "moderator").should be(true)
+      @admin.has_any_role?("dummy", "dumber").should be(false)
+    end
+
+    it "should remove a global role of a user" do 
+      expect { @admin.has_no_role("admin") }.to change{ @admin.roles.size }.by(-1)
+      @admin.has_role?("admin").should be(false)
+      @admin.has_role?("staff").should be(true)
+      @admin.has_role?("moderator", Forum.first).should be(true)
+      @admin.has_role?("manager", Group).should be(true)
+    end
+
+    it "should remove a class scoped role of a user" do
+      expect { @admin.has_no_role("manager") }.to change{ @admin.roles.size }.by(-1)
+      @admin.has_role?("staff").should be(true)
+      @admin.has_role?("moderator", Forum.first).should be(true)
+      @admin.has_role?("manager", Group).should be(false)
     end
-  
-    context "with different roles" do 
-      before(:all) do 
-        @user = Rolify.user_cname.last
-        @user.has_role "admin"
-        @user.has_role "moderator", Forum.first
-        @user.has_role "visitor", Forum.last
-        @user.has_role "anonymous"
-      end
-    
-      it "should get a global role" do
-        @user.has_role?("admin").should be(true)
-        @user.has_role?("anonymous").should be(true)
-      end
     
-      it "should get a scoped role" do
-        @user.has_role?("moderator", Forum.first).should be(true)
-        @user.has_role?("visitor", Forum.last).should be(true)
-      end
+    it "should remove two instance scoped roles of a user" do
+      expect { @admin.has_no_role("moderator") }.to change{ @admin.roles.size }.by(-2)
+      @admin.has_role?("staff").should be(true)
+      @admin.has_role?("moderator", Forum.first).should be(false)
+      @admin.has_role?("moderator", Forum.find(2)).should be(false)
+      @admin.has_role?("manager", Group).should be(true)
+    end
+
+    it "should not remove another global role" do 
+      expect { @admin.has_no_role("global") }.not_to change{ @admin.roles.size }
+    end
+  end
+
+  context "with an instance scoped role" do
+    before do
+      @moderator = Rolify.user_cname.find(2)
+      @moderator.has_role "moderator", Forum.first
+      @moderator.has_role "soldier"
+    end
+
+    it "should set an instance scoped role" do
+      expect { @moderator.has_role "visitor", Forum.last }.to change{ Rolify.role_cname.count }.by(1)
+      visitor = Rolify.role_cname.last
+      visitor.name.should eq("visitor")
+      visitor.resource.should eq(Forum.last)
+    end
+
+    it "should not create another role if already existing" do
+      expect { @moderator.has_role "moderator", Forum.first }.not_to change{ Rolify.role_cname.count }
+      expect { @moderator.has_role "moderator", Forum.first }.not_to change{ @moderator.roles.size }
+    end
+
+    it "should get an instance scoped role" do
+      @moderator.has_role?("moderator", Forum.first).should be(true)
+    end
+
+    it "should get any of instance scoped role" do
+      @moderator.has_role?("moderator", :any).should be(true)
+    end
+
+    it "should not get an instance scoped role when asking for a global" do
+      @moderator.has_role?("moderator").should be(false)
+    end
+
+    it "should not get an instance scoped role when asking for a class scoped" do 
+      @moderator.has_role?("moderator", Forum).should be(false)
+    end
+
+    it "should be able to use dynamic shortcut", :if => dynamic do
+      @moderator.is_moderator?.should be(false)
+      @moderator.is_moderator_of?(Forum.first).should be(true)
+      @moderator.is_moderator_of?(Forum.last).should be(false)
+      @moderator.is_moderator_of?(Forum).should be(false)
+    end
+
+    it "should not get a global role" do
+      @moderator.has_role?("admin").should be(false)
+    end
+
+    it "should not get the same role on another resource" do
+      Rolify.role_cname.create(:name => "moderator", :resource => Forum.last)
+      @moderator.has_role?("moderator", Forum.last).should be(false)
+    end
+
+    it "should not get the another role on the same resource" do
+      Rolify.role_cname.create(:name => "tourist", :resource => Forum.first)
+      @moderator.has_role?("tourist", Forum.first).should be(false)
+      @moderator.has_role?("tourist", :any).should be(false)
+    end
+
+    it "should not get inexisting role" do
+      @moderator.has_role?("dummy", Forum.last).should be(false)
+      @moderator.has_role?("dumber").should be(false)
+    end
+
+    it "should check if user has all of a scoped roles set" do
+      @moderator.has_all_roles?({ :name => "visitor", :resource => Forum.last }).should be(true)
+      @moderator.has_all_roles?({ :name => "moderator", :resource => Forum.first }, 
+      { :name => "visitor", :resource => Forum.last }).should be(true)
+      @moderator.has_all_roles?({ :name => "moderator", :resource => Forum.first }, 
+      { :name => "dummy", :resource => Forum.last }).should be(false)
+      @moderator.has_all_roles?({ :name => "dummy", :resource => Forum.first }, 
+      { :name => "dumber", :resource => Forum.last }).should be(false)
+    end
+
+    it "should check if user has any of a scoped roles set" do
+      @moderator.has_any_role?( { :name => "visitor", :resource => Forum.last }).should be(true)
+      @moderator.has_any_role?( { :name => "moderator", :resource => Forum.first }, 
+      { :name => "visitor", :resource => Forum.last }).should be(true)
+      @moderator.has_any_role?( { :name => "moderator", :resource => Forum.first }, 
+      { :name => "dummy", :resource => Forum.last }).should be(true)
+      @moderator.has_any_role?( { :name => "dummy", :resource => Forum.first }, 
+      { :name => "dumber", :resource => Forum.last }).should be(false)
+    end
+
+    it "should not remove a global role of a user" do 
+      expect { @moderator.has_no_role("soldier", Forum.first) }.not_to change{ @moderator.roles.size }
+    end
+
+    it "should remove a scoped role of a user" do 
+      expect { @moderator.has_no_role("moderator", Forum.first) }.to change{ @moderator.roles.size }.by(-1)
+      @moderator.has_role?("moderator", Forum.first).should be(false)
+      @moderator.has_role?("soldier").should be(true)
+    end
+
+    it "should not remove another scoped role" do
+      expect { @moderator.has_no_role("visitor", Forum.first) }.not_to change{ @moderator.roles.size }
+    end
+  end
+
+  context "with a class scoped role" do
+    before do
+      @manager = Rolify.user_cname.find(3)
+      @manager.has_role "manager", Forum
+      @manager.has_role "moderator", Forum.first
+      @manager.has_role "moderator", Forum.last
+      @manager.has_role "warrior"
+    end
+
+    it "should set a class scoped role" do
+      expect { @manager.has_role "player", Forum }.to change{ Rolify.role_cname.count }.by(1)
+      player = Rolify.role_cname.last
+      player.name.should eq("player")
+      player.resource_type.should eq(Forum.to_s)
+    end
+
+    it "should not create another role if already existing" do
+      expect { @manager.has_role "manager", Forum }.not_to change{ Rolify.role_cname.count }
+      expect { @manager.has_role "manager", Forum }.not_to change{ @manager.roles.size }
+    end
+
+    it "should get a class scoped role" do
+      @manager.has_role?("manager", Forum).should be(true)
+      @manager.has_role?("manager", Forum.first).should be(true)
+    end
+
+    it "should get any of class scoped role" do
+      @manager.has_role?("manager", :any).should be(true)
+    end
+
+    it "should not get a scoped role when asking for a global" do
+      @manager.has_role?("manager").should be(false)
+    end
+
+    it "should be able to use dynamic shortcut", :if => dynamic do
+      @manager.is_manager?.should be(false)
+      @manager.is_manager_of?(Forum.first).should be(true)
+      @manager.is_manager_of?(Forum.last).should be(true)
+      @manager.is_manager_of?(Forum).should be(true)
+      @manager.is_manager_of?(Group).should be(false)
+    end
+
+    it "should not get a global role" do
+      @manager.has_role?("admin").should be(false)
+    end
+
+    it "should not get the same role on another resource" do
+      Rolify.role_cname.create(:name => "manager", :resource_type => "Group")
+      @manager.has_role?("manager", Group).should be(false)
+    end
+
+    it "should not get the another role on the same resource" do
+      Rolify.role_cname.create(:name => "member", :resource_type => "Forum")
+      @manager.has_role?("member", Forum).should be(false)
+      @manager.has_role?("member", :any).should be(false)
+    end
+
+    it "should not get inexisting role" do
+      @manager.has_role?("dummy", Forum).should be(false)
+      @manager.has_role?("dumber").should be(false)
+    end
+
+    it "should check if user has all of a scoped roles set" do
+      @manager.has_all_roles?({ :name => "player", :resource => Forum }).should be(true)
+      @manager.has_all_roles?({ :name => "manager", :resource => Forum }, 
+      { :name => "player", :resource => Forum }).should be(true)
+      @manager.has_all_roles?({ :name => "manager", :resource => Forum }, 
+      { :name => "dummy", :resource => Forum }).should be(false)
+      @manager.has_all_roles?({ :name => "dummy", :resource => Forum }, 
+      { :name => "dumber", :resource => Group }).should be(false)
+    end
+
+    it "should check if user has any of a scoped roles set" do
+      @manager.has_any_role?( { :name => "player", :resource => Forum }).should be(true)
+      @manager.has_any_role?( { :name => "manager", :resource => Forum }, 
+      { :name => "player", :resource => Forum }).should be(true)
+      @manager.has_any_role?( { :name => "manager", :resource => Forum }, 
+      { :name => "dummy", :resource => Forum }).should be(true)
+      @manager.has_any_role?( { :name => "dummy", :resource => Forum }, 
+      { :name => "dumber", :resource => Group }).should be(false)
+    end
+
+    it "should not remove a global role of a user" do 
+      expect { @manager.has_no_role("warrior", Forum) }.not_to change{ @manager.roles.size }
+    end
+
+    it "should remove a class scoped role of a user" do 
+      expect { @manager.has_no_role("manager", Forum) }.to change{ @manager.roles.size }.by(-1)
+      @manager.has_role?("manager", Forum).should be(false)
+      @manager.has_role?("moderator", Forum.first).should be(true)
+      @manager.has_role?("moderator", Forum.last).should be(true)
+      @manager.has_role?("warrior").should be(true)
+    end
     
-      it "should check if user has all of a mix of global and scoped roles set" do
-        @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.first }).should be(true)
-        @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.last }).should be(false)
-        @user.has_all_roles?({ :name => "admin", :resource => Forum.first }, { :name => "moderator", :resource => Forum.first }).should be(true)
-        @user.has_all_roles?("dummy", { :name => "dumber", :resource => Forum.last }).should be(false)
-      end
-
-      it "should check if user has any of a mix of global and scoped roles set" do
-        @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.first }).should be(true)
-        @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.last }).should be(true)
-        @user.has_any_role?({ :name => "admin", :resource => Forum.first }, { :name => "moderator", :resource => Forum.last }).should be(true)
-        @user.has_any_role?("dummy", { :name => "dumber", :resource => Forum.last }).should be(false)
-      end
+    it "should remove two instance scoped roles of a user" do 
+      expect { @manager.has_no_role("moderator", Forum) }.to change{ @manager.roles.size }.by(-2)
+      @manager.has_role?("manager", Forum).should be(true)
+      @manager.has_role?("moderator", Forum.first).should be(false)
+      @manager.has_role?("moderator", Forum.last).should be(false)
+      @manager.has_role?("warrior").should be(true)
+    end
+
+    it "should not remove another scoped role" do
+      expect { @manager.has_no_role("visitor", Forum.first) }.not_to change{ @manager.roles.size }
+    end
+  end
+
+  context "with different roles" do 
+    before do 
+      @user = Rolify.user_cname.find(4)
+      @user.has_role "admin"
+      @user.has_role "anonymous"
+      @user.has_role "moderator", Forum.first
+      @user.has_role "visitor", Forum.last
+      @user.has_role "manager", Forum
+      @user.has_role "leader", Group
+    end
+
+    it "should get a global role" do
+      @user.has_role?("admin").should be(true)
+      @user.has_role?("anonymous").should be(true)
     end
 
+    it "should get an instance scoped role" do
+      @user.has_role?("moderator", Forum.first).should be(true)
+      @user.has_role?("visitor", Forum.last).should be(true)
+    end
+
+    it "should get an class scoped role" do
+      @user.has_role?("manager", Forum).should be(true)
+      @user.has_role?("leader", Group).should be(true)
+    end
+
+    it "should check if user has all of a mix of global and scoped roles set" do
+      @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Forum }).should be(false)
+      @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Group }).should be(false)
+      @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Group.first }).should be(false)
+      @user.has_all_roles?({ :name => "admin", :resource => Forum }, { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_all_roles?({ :name => "admin", :resource => Forum.first }, { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_all_roles?("admin", { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Forum.first }).should be(true)
+      @user.has_all_roles?("dummy", { :name => "dumber", :resource => Forum.last }, { :name => "dumberer", :resource => Forum }).should be(false)
+    end
+
+    it "should check if user has any of a mix of global and scoped roles set" do
+      @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.first }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Group }).should be(true)
+      @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Group.first }).should be(true)
+      @user.has_any_role?({ :name => "admin", :resource => Forum }, { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_any_role?({ :name => "admin", :resource => Forum.first }, { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Forum }).should be(true)
+      @user.has_any_role?("admin", { :name => "moderator", :resource => Forum.last }, { :name => "manager", :resource => Forum.first }).should be(true)
+      @user.has_any_role?("dummy", { :name => "dumber", :resource => Forum.last }, { :name => "dumberer", :resource => Forum }).should be(false)
+    end
+  end
+
 end
 
 describe Rolify do

data/spec/spec_helper.rb

@@ -2,8 +2,9 @@ require 'rubygems'
 require 'bundler/setup'
 
 Bundler.require(:default, :test)
-
 require 'rolify'
+require 'ammeter/init'
+
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
 load File.dirname(__FILE__) + '/support/schema.rb'

data/spec/support/data.rb

@@ -1,9 +1,16 @@
+# Users
 User.create(:login => "admin")
 User.create(:login => "moderator")
 User.create(:login => "god")
+User.create(:login => "zombie")
+Customer.create(:login => "customer VIP")
+Customer.create(:login => "customer Doe")
+Customer.create(:login => "customer John")
+Customer.create(:login => "customer Edgar")
+
+# Resources
 Forum.create(:name => "forum 1")
 Forum.create(:name => "forum 2")
 Forum.create(:name => "forum 3")
-
-Customer.create(:login => "customer VIP")
-Customer.create(:login => "customer Doe")
+Group.create(:name => "group 1")
+Group.create(:name => "group 2")

data/spec/support/models.rb

@@ -12,6 +12,9 @@ end
 class Forum < ActiveRecord::Base
 end
 
+class Group < ActiveRecord::Base
+end
+
 class Customer < ActiveRecord::Base
   has_and_belongs_to_many :roles, :join_table => :customers_privileges, :class_name => "Privilege"
   include Rolify::Roles

data/spec/support/schema.rb

@@ -20,6 +20,10 @@ ActiveRecord::Schema.define do
   create_table(:forums) do |t|
     t.string :name
   end
+  
+  create_table(:groups) do |t|
+    t.string :name
+  end
 
   create_table(:privileges) do |t|
     t.string :name

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rolify
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,23 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-26 00:00:00.000000000Z
+date: 2011-10-14 00:00:00.000000000 -04:00
+default_executable: 
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &2152413060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152413060
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &79887380 !ruby/object:Gem::Requirement
+  requirement: &2152483900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,18 +33,51 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79887380
+  version_requirements: *2152483900
 - !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &79887130 !ruby/object:Gem::Requirement
+  name: ammeter
+  requirement: &2152578220 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.1.0.rc1
-  type: :runtime
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152578220
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2160177360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  version_requirements: *79887130
+  version_requirements: *2160177360
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2160394640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160394640
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2160528120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160528120
 description: ! 'Very simple Roles library without any authorization enforcement (built
   to use with cancan) supporting scope on resource: user.is_moderator?(Forum.first)
   => # return false if user is moderator of another Forum '
@@ -57,12 +102,13 @@ files:
 - lib/rolify/role.rb
 - lib/rolify/version.rb
 - rolify.gemspec
+- spec/generators/rolify/role/role_generator_spec.rb
 - spec/rolify/role_spec.rb
-- spec/spec.opts
 - spec/spec_helper.rb
 - spec/support/data.rb
 - spec/support/models.rb
 - spec/support/schema.rb
+has_rdoc: true
 homepage: https://github.com/EppO/rolify
 licenses: []
 post_install_message: 
@@ -83,8 +129,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rolify
-rubygems_version: 1.8.5
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Roles library with resource scoping
-test_files: []
+test_files:
+- spec/generators/rolify/role/role_generator_spec.rb
+- spec/rolify/role_spec.rb
+- spec/spec_helper.rb
+- spec/support/data.rb
+- spec/support/models.rb
+- spec/support/schema.rb

data/spec/spec.opts

@@ -1,2 +0,0 @@
---color
---backtrace