rolify 3.4.0 → 3.4.1

data/lib/rolify/role.rb

@@ -9,8 +9,8 @@ module Rolify
     end
           
     def add_role(role_name, resource = nil)
-      role = self.class.adapter.find_or_create_by(role_name.to_s, 
-                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
+      role = self.class.adapter.find_or_create_by(role_name.to_s,
+                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource),
                                                   (resource.id if resource && !resource.is_a?(Class)))
 
       if !roles.include?(role)
@@ -23,6 +23,12 @@ module Rolify
     deprecate :has_role, :add_role
 
     def has_role?(role_name, resource = nil)
+      @r_map ||= {}
+      role_n_resource = role_name.to_s + resource.to_s
+      @r_map[role_n_resource].nil? ? @r_map[role_n_resource] = has_role_helper(role_name, resource) : @r_map[role_n_resource]
+    end
+
+    def has_role_helper(role_name, resource = nil)
       if new_record?
         self.roles.detect { |r| r.name == role_name.to_s && (r.resource == resource || resource.nil?) }.present?
       else

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "3.4.0"
+  VERSION = "3.4.1"
 end

data/rolify.gemspec

@@ -1,15 +1,15 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rolify/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'rolify/version'
 
 Gem::Specification.new do |s|
-  s.name        = "rolify"
+  s.name        = 'rolify'
   s.version     = Rolify::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.license     = "MIT"
-  s.authors     = ["Florent Monbillard"]
-  s.email       = ["f.monbillard@gmail.com"]
-  s.homepage    = "http://eppo.github.com/rolify/"
+  s.license     = 'MIT'
+  s.authors     = ['Florent Monbillard']
+  s.email       = ['f.monbillard@gmail.com']
+  s.homepage    = 'http://eppo.github.com/rolify/'
   s.summary     = %q{Roles library with resource scoping}
   s.description = %q{Very simple Roles library without any authorization enforcement supporting scope on resource objects (instance or class). Supports ActiveRecord and Mongoid ORMs.}
 
@@ -18,12 +18,12 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  
-  s.add_development_dependency "ammeter"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", ">= 2.0"
-  s.add_development_dependency "rspec-rails", ">= 2.0"
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "fuubar" 
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'ammeter',     '~> 1.1.2'
+  s.add_development_dependency 'rake',        '~> 10.3.2'
+  s.add_development_dependency 'rspec',       '2.99.0'
+  s.add_development_dependency 'rspec-rails', '2.99.0'
+  s.add_development_dependency 'bundler',     '~> 1.6.2'
+  s.add_development_dependency 'fuubar',      '~> 1.3.3'
 end

data/spec/rolify/config_spec.rb

@@ -20,7 +20,7 @@ describe Rolify do
     context "using defaults values" do
       subject { Rolify.dynamic_shortcuts }
 
-      it { should be_false }
+      it { should be_falsey }
     end
 
     context "using custom values" do
@@ -30,7 +30,7 @@ describe Rolify do
 
       subject { Rolify.dynamic_shortcuts }
 
-      it { should be_true }
+      it { should be_truthy }
     end
   end
 
@@ -127,7 +127,7 @@ describe Rolify do
       context "using defaults values" do
         subject { Rolify.dynamic_shortcuts }
 
-        it { should be_false }
+        it { should be_falsey }
       end
       
       context "using custom values" do
@@ -138,7 +138,7 @@ describe Rolify do
 
           subject { Rolify.dynamic_shortcuts }
 
-          it { should be_true }
+          it { should be_truthy }
         end
 
         context "using :use_dynamic_shortcuts method" do
@@ -148,7 +148,7 @@ describe Rolify do
 
           subject { Rolify.dynamic_shortcuts }
 
-          it { should be_true }
+          it { should be_truthy }
         end
       end
     end
@@ -162,7 +162,7 @@ describe Rolify do
       end
     end
     
-    its(:dynamic_shortcuts) { should be_true }
+    its(:dynamic_shortcuts) { should be_truthy }
     its(:orm) { should eq("mongoid") }
     
     context "on the User class", :if => ENV['ADAPTER'] == 'mongoid' do
@@ -183,7 +183,6 @@ describe Rolify do
       end
 
       subject { Forum }
-      
       it { should satisfy { |u| u.include? Rolify::Resource }}
       its("adapter.class") { should be(Rolify::Adapter::ResourceAdapter) }
     end

data/spec/rolify/resource_spec.rb

@@ -3,10 +3,11 @@ require "spec_helper"
 describe Rolify::Resource do
   before(:all) do
     reset_defaults
-    User.rolify
+    silence_warnings { User.rolify }
     Forum.resourcify
     Group.resourcify
     Team.resourcify
+    Organization.resourcify
     Role.destroy_all
   end
 
@@ -24,6 +25,7 @@ describe Rolify::Resource do
   let!(:sneaky_role)     { tourist.add_role(:group, Forum.first) }
   let!(:captain_role)    { captain.add_role(:captain, Team.first) }
   let!(:player_role)     { captain.add_role(:player, Team.last) }
+  let!(:company_role)    { admin.add_role(:owner, Company.first) }
 
   describe ".with_roles" do
     subject { Group }
@@ -38,11 +40,11 @@ describe Rolify::Resource do
         it "should include Forum instances with forum role" do
           subject.with_role(:forum).should =~ [ Forum.first, Forum.last ]
         end
-        
+
         it "should include Forum instances with godfather role" do
           subject.with_role(:godfather).should =~ Forum.all.to_a
         end
-        
+
         it "should be able to modify the resource", :if => ENV['ADAPTER'] == 'active_record' do
           forum_resource = subject.with_role(:forum).first
           forum_resource.name = "modified name"
@@ -138,14 +140,21 @@ describe Rolify::Resource do
 
       end
     end
-    
+
     context "with a model not having ID column" do
       subject { Team }
-      
+
       it "should find Team instance using team_code column" do
         subject.with_roles([:captain, :player], captain).should =~ [ Team.first, Team.last ]
       end
     end
+
+    context "with a resource using STI" do
+      subject { Organization }
+      it "should find instances of children classes" do
+        subject.with_roles(:owner, admin).should =~ [ Company.first ]
+      end
+    end
   end
 
   describe ".find_role" do
@@ -336,6 +345,13 @@ describe Rolify::Resource do
         end
       end
     end
+
+    context "with a resource using STI" do
+      subject{ Organization }
+      it "should find instances of children classes" do
+        subject.find_roles(:owner, admin).should =~ [company_role]
+      end
+    end
   end
 
   describe "#roles" do
@@ -387,4 +403,4 @@ describe Rolify::Resource do
       its(:applied_roles) { should_not include(forum_role, godfather_role, sneaky_role, tourist_role) }
     end
   end
-end
+end

data/spec/rolify/shared_contexts.rb

@@ -79,6 +79,7 @@ shared_context "mixed scoped roles", :scope => :mixed do
   let!(:root) { provision_user(user_class.first, [ :admin, :staff, [ :moderator, Group ], [ :visitor, Forum.last ] ]) }
   let!(:modo) { provision_user(user_class.where(:login => "moderator").first, [[ :moderator, Forum ], [ :manager, Group ], [ :visitor, Group.first ]])}
   let!(:visitor) { provision_user(user_class.last, [[ :visitor, Forum.last ]]) }
+  let!(:owner) { provision_user(user_class.first, [[:owner, Company.first]]) }
 end
 
 def create_other_roles

data/spec/rolify/shared_examples/shared_examples_for_callbacks.rb

@@ -14,7 +14,7 @@ shared_examples_for "Rolify.callbacks" do
       it "should receive callback" do
         rolify_options = { :role_cname => role_class.to_s, :before_add => :role_callback }
         rolify_options[:role_join_table_name] = join_table if defined? join_table
-        user_class.rolify rolify_options
+        silence_warnings { user_class.rolify rolify_options }
         @user = user_class.first
         @user.stub(:role_callback)
         @user.should_receive(:role_callback)
@@ -26,7 +26,7 @@ shared_examples_for "Rolify.callbacks" do
       it "should receive callback" do
         rolify_options = { :role_cname => role_class.to_s, :after_add => :role_callback }
         rolify_options[:role_join_table_name] = join_table if defined? join_table
-        user_class.rolify rolify_options
+        silence_warnings { user_class.rolify rolify_options }
         @user = user_class.first
         @user.stub(:role_callback)
         @user.should_receive(:role_callback)
@@ -38,7 +38,7 @@ shared_examples_for "Rolify.callbacks" do
       it "should receive callback" do
         rolify_options = { :role_cname => role_class.to_s, :before_remove => :role_callback }
         rolify_options[:role_join_table_name] = join_table if defined? join_table
-        user_class.rolify rolify_options
+        silence_warnings { user_class.rolify rolify_options }
         @user = user_class.first
         @user.add_role :admin
         @user.stub(:role_callback)
@@ -52,7 +52,7 @@ shared_examples_for "Rolify.callbacks" do
       it "should receive callback" do
         rolify_options = { :role_cname => role_class.to_s, :after_remove => :role_callback }
         rolify_options[:role_join_table_name] = join_table if defined? join_table
-        user_class.rolify rolify_options
+        silence_warnings { user_class.rolify rolify_options }
         @user = user_class.first
         @user.add_role :admin
         @user.stub(:role_callback)

data/spec/rolify/shared_examples/shared_examples_for_dynamic.rb

@@ -4,13 +4,13 @@ shared_examples_for Rolify::Dynamic do
     role_class.destroy_all
     rolify_options = { :role_cname => role_class.to_s }
     rolify_options[:role_join_table_name] = join_table if defined? join_table
-    user_class.rolify rolify_options
+    silence_warnings { user_class.rolify rolify_options }
     Forum.resourcify :roles, :role_cname => role_class.to_s
     Group.resourcify :roles, :role_cname => role_class.to_s
   end
-  
+
   context "using a global role" do
-    subject do 
+    subject do
       admin = user_class.first
       admin.add_role :admin
       admin.add_role :moderator, Forum.first
@@ -25,30 +25,30 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_admin?.should be(true) }
     it { subject.is_admin?.should be(true) }
     it { subject.is_admin?.should be(true) }
-    
+
     context "removing the role on the last user having it" do
       before do
         subject.remove_role :solo
       end
-      
+
       it { should_not respond_to(:is_solo?) }
       it { subject.is_solo?.should be(false) }
     end
   end
-  
+
   context "using a resource scoped role" do
-    subject do 
+    subject do
       moderator = user_class.where(:login => "moderator").first
       moderator.add_role :moderator, Forum.first
       moderator.add_role :sole_mio, Forum.last
       moderator
     end
-    
+
     it { should respond_to(:is_moderator?).with(0).arguments }
     it { should respond_to(:is_moderator_of?).with(1).arguments }
     it { should_not respond_to(:is_god?) }
     it { should_not respond_to(:is_god_of?) }
-    
+
     it { subject.is_moderator?.should be(false) }
     it { subject.is_moderator_of?(Forum).should be(false) }
     it { subject.is_moderator_of?(Forum.first).should be(true) }
@@ -56,30 +56,30 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_moderator_of?(Group).should be(false) }
     it { subject.is_moderator_of?(Group.first).should be(false) }
     it { subject.is_moderator_of?(Group.last).should be(false) }
-    
+
     context "removing the role on the last user having it" do
       before do
         subject.remove_role :sole_mio, Forum.last
       end
-      
+
       it { should_not respond_to(:is_sole_mio?) }
       it { subject.is_sole_mio?.should be(false) }
     end
   end
-  
+
   context "using a class scoped role" do
-    subject do 
+    subject do
       manager = user_class.where(:login => "god").first
       manager.add_role :manager, Forum
       manager.add_role :only_me, Forum
       manager
     end
-    
+
     it { should respond_to(:is_manager?).with(0).arguments }
     it { should respond_to(:is_manager_of?).with(1).arguments }
     it { should_not respond_to(:is_god?) }
     it { should_not respond_to(:is_god_of?) }
-    
+
     it { subject.is_manager?.should be(false) }
     it { subject.is_manager_of?(Forum).should be(true) }
     it { subject.is_manager_of?(Forum.first).should be(true) }
@@ -87,46 +87,46 @@ shared_examples_for Rolify::Dynamic do
     it { subject.is_manager_of?(Group).should be(false) }
     it { subject.is_manager_of?(Group.first).should be(false) }
     it { subject.is_manager_of?(Group.last).should be(false) }
-    
+
     context "removing the role on the last user having it" do
       before do
         subject.remove_role :only_me, Forum
       end
-      
+
       it { should_not respond_to(:is_only_me?) }
       it { subject.is_only_me?.should be(false) }
     end
   end
-  
+
   context "if the role doesn't exist in the database" do
-    
+
     subject { user_class.first }
-    
+
     context "using a global role" do
       before(:all) do
         other_guy = user_class.last
         other_guy.add_role :superman
       end
-  
+
       it { should respond_to(:is_superman?).with(0).arguments }
       it { should_not respond_to(:is_superman_of?) }
       it { should_not respond_to(:is_god?) }
-      
+
       it { subject.is_superman?.should be(false) }
       it { subject.is_god?.should be(false) }
     end
-    
+
     context "using a resource scope role" do
       before(:all) do
         other_guy = user_class.last
         other_guy.add_role :batman, Forum.first
       end
-      
+
       it { should respond_to(:is_batman?).with(0).arguments }
       it { should respond_to(:is_batman_of?).with(1).arguments }
       it { should_not respond_to(:is_god?) }
       it { should_not respond_to(:is_god_of?) }
-      
+
       it { subject.is_batman?.should be(false) }
       it { subject.is_batman_of?(Forum).should be(false) }
       it { subject.is_batman_of?(Forum.first).should be(false) }
@@ -134,7 +134,7 @@ shared_examples_for Rolify::Dynamic do
       it { subject.is_batman_of?(Group).should be(false) }
       it { subject.is_batman_of?(Group.first).should be(false) }
       it { subject.is_batman_of?(Group.last).should be(false) }
-      
+
       it { subject.is_god?.should be(false) }
       it { subject.is_god_of?(Forum).should be(false) }
       it { subject.is_god_of?(Forum.first).should be(false) }
@@ -144,4 +144,4 @@ shared_examples_for Rolify::Dynamic do
       it { subject.is_god_of?(Group.last).should be(false) }
     end
   end
-end
+end

data/spec/rolify/shared_examples/shared_examples_for_finders.rb

@@ -42,6 +42,10 @@ shared_examples_for :finders do |param_name, param_method|
           it { subject.with_role("moderator".send(param_method), Group.first).should eq([ root ]) }
           it { subject.with_role("visitor".send(param_method), Group.first).should eq([ modo ]) }
         end
+
+        context "on Company.first_instance" do
+          it { subject.with_role("owner".send(param_method), Company.first).should eq([ owner ]) }
+        end
       end
     end
 

data/spec/rolify/shared_examples/shared_examples_for_has_all_roles.rb

@@ -2,54 +2,54 @@ shared_examples_for "#has_all_roles?_examples" do |param_name, param_method|
   context "using #{param_name} as parameter" do
     context "with a global role", :scope => :global do  
       context "on global roles only request" do
-        it { subject.has_all_roles?("staff".send(param_method)).should be_true }
-        it { subject.has_all_roles?("admin".send(param_method), "staff".send(param_method)).should be_true }
-        it { subject.has_all_roles?("admin".send(param_method), "dummy".send(param_method)).should be_false }
-        it { subject.has_all_roles?("dummy".send(param_method), "dumber".send(param_method)).should be_false }
+        it { subject.has_all_roles?("staff".send(param_method)).should be_truthy }
+        it { subject.has_all_roles?("admin".send(param_method), "staff".send(param_method)).should be_truthy }
+        it { subject.has_all_roles?("admin".send(param_method), "dummy".send(param_method)).should be_falsey }
+        it { subject.has_all_roles?("dummy".send(param_method), "dumber".send(param_method)).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_false}
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => :any }, { :name => "admin".send(param_method), :resource => Group }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum }, { :name => "staff".send(param_method), :resource => Group.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "admin".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "admin".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => :any }).should be_falsey}
       end
     end
     
     context "with a class scoped role", :scope => :class do        
       context "on class scoped roles only" do
-        it { subject.has_all_roles?({ :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => Forum }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_false }
-        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_false }
+        it { subject.has_all_roles?({ :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => Forum }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => :any }, { :name => "player".send(param_method), :resource => :any }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum }, { :name => "dummy".send(param_method), :resource => :any }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum }, { :name => "dumber".send(param_method), :resource => Group }).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_true }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "manager".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Group }, { :name => "moderator".send(param_method), :resource => Forum.first }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "manager".send(param_method), :resource => Forum.last }, { :name => "warrior".send(param_method), :resource => Forum.last }).should be_truthy }
       end
     end
     
     context "with a instance scoped role", :scope => :instance do
       context "on instance scoped roles only" do
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => :any }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum }).should be_false }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_true }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_false }
-        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => Forum.last }).should be_false }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => :any }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => :any }, { :name => "anonymous".send(param_method), :resource => Forum }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "anonymous".send(param_method), :resource => Forum.last }).should be_truthy }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "moderator".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "dummy".send(param_method), :resource => Forum.last }).should be_falsey }
+        it { subject.has_all_roles?({ :name => "dummy".send(param_method), :resource => Forum.first }, { :name => "dumber".send(param_method), :resource => Forum.last }).should be_falsey }
       end
       
       context "on mixed scoped roles" do
-        it { subject.has_all_roles?({ :name => "visitor".send(param_method), :resource => Forum.last }).should be_true }
+        it { subject.has_all_roles?({ :name => "visitor".send(param_method), :resource => Forum.last }).should be_truthy }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => Forum.first }, { :name => "visitor".send(param_method), :resource => Forum }).should be(true) }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => Forum.last }, { :name => "visitor".send(param_method), :resource => Forum }).should be(false) }
         it { subject.has_all_roles?("soldier".send(param_method), { :name => "moderator".send(param_method), :resource => :any }, { :name => "visitor".send(param_method), :resource => Forum }).should be(true) }