rolify 3.1.0 → 3.2.0.rc2

data/lib/rolify/railtie.rb

@@ -8,7 +8,7 @@ module Rolify
         ActiveRecord::Base.send :extend, Rolify
       end
       
-      config.after_initialize do
+      config.before_initialize do
         ::Mongoid::Document.module_eval do
           def self.included(base)
             base.extend Rolify

data/lib/rolify/resource.rb

@@ -14,8 +14,9 @@ module Rolify
 
       def with_role(role_name, user = nil)
         resources = self.adapter.resources_find(self.role_class.to_s.tableize, self, role_name)
-        user ? self.adapter.in(resources, user.roles.where(:name => role_name)) : resources
+        user ? self.adapter.in(resources, user, role_name) : resources
       end
+      alias :with_roles :with_role
     end
     
     def applied_roles

data/lib/rolify/role.rb

@@ -1,9 +1,15 @@
+require "rolify/finders"
+
 module Rolify
   module Role
     extend Utils
     
+    def self.included(base)
+      base.extend Finders
+    end
+          
     def add_role(role_name, resource = nil)
-      role = self.class.adapter.find_or_create_by(role_name, 
+      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)))
 
@@ -17,7 +23,11 @@ module Rolify
     deprecate :has_role, :add_role
 
     def has_role?(role_name, resource = nil)
-      self.class.adapter.where(self.roles, :name => role_name, :resource => resource).size > 0
+      if new_record?
+        self.roles.detect { |r| r.name == role_name.to_s && (r.resource == resource || resource.nil?) }.present?
+      else
+        self.class.adapter.where(self.roles, :name => role_name, :resource => resource).size > 0
+      end
     end
 
     def has_all_roles?(*args)

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "3.1.0"
+  VERSION = "3.2.0.rc2"
 end

data/rolify.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Florent Monbillard"]
   s.email       = ["f.monbillard@gmail.com"]
-  s.homepage    = "https://github.com/EppO/rolify"
+  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)}
+  s.description = %q{Very simple Roles library without any authorization enforcement supporting scope on resource objects (instance or class). Supports ActiveRecord and Mongoid ORMs.}
 
   s.rubyforge_project = s.name
 
@@ -23,10 +23,10 @@ Gem::Specification.new do |s|
     s.add_development_dependency "activerecord-jdbcsqlite3-adapter"
   else
     s.add_development_dependency "sqlite3"
+    s.add_development_dependency "bson_ext" if RUBY_VERSION < "2.0.0"
   end
   s.add_development_dependency "activerecord", ">= 3.1.0"
-  s.add_development_dependency "mongoid", ">= 2.3"
-  s.add_development_dependency "bson_ext"
+  s.add_development_dependency "mongoid", ">= 3.0"
   s.add_development_dependency "ammeter"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"

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

@@ -46,7 +46,7 @@ describe Rolify::Generators::RoleGenerator do
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
+      it { should contain /class User < ActiveRecord::Base\n  rolify\n/ }
     end
     
     describe 'migration file' do
@@ -88,10 +88,10 @@ describe Rolify::Generators::RoleGenerator do
       it { should contain "belongs_to :resource, :polymorphic => true" }
     end
     
-    describe 'app/models/client.rb' do
+    describe 'app/models/admin_user.rb' do
       subject { file('app/models/admin_user.rb') }
       
-      it { should contain "rolify" }
+      it { should contain /class AdminUser < ActiveRecord::Base\n  rolify :role_cname => 'AdminRole'\n/ }
     end
     
     describe 'migration file' do
@@ -103,61 +103,19 @@ describe Rolify::Generators::RoleGenerator do
     end
   end
   
-  describe 'specifying dynamic shortcuts' do
-    before(:all) { arguments [ "Role", "User", "--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.configure do |config|"}
-      it { should_not contain "# config.use_dynamic_shortcuts" }
-      it { should contain "# config.use_mongoid" }
-    end
-    
-    describe 'app/models/role.rb' do
-      subject { file('app/models/role.rb') }
-      it { should exist }
-      it { should contain "class Role < ActiveRecord::Base" }
-      it { should contain "has_and_belongs_to_many :users, :join_table => :users_roles" }
-      it { should contain "belongs_to :resource, :polymorphic => true" }
-    end
-    
-    describe 'app/models/user.rb' do
-      subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
-    end
-    
-    describe 'migration file' do
-      subject { migration_file('db/migrate/rolify_create_roles.rb') }
-      
-      it { should be_a_migration }
-      it { should contain "create_table(:roles) do" }
-      it { should contain "create_table(:users_roles, :id => false) do" }
-    end
-  end
-  
   describe 'specifying orm adapter' do 
     before(:all) { arguments [ "Role", "User", "mongoid" ] }
     
     before { 
       capture(:stdout) {
         generator.create_file "app/models/user.rb" do
-          <<-CLASS 
-          class User
-            include Mongoid::Document
+<<-CLASS 
+class User
+  include Mongoid::Document
 
-            field :login, :type => String
-          end
-          CLASS
+  field :login, :type => String
+end
+CLASS
         end
       }
       run_generator
@@ -178,20 +136,18 @@ describe Rolify::Generators::RoleGenerator do
       it { should contain "has_and_belongs_to_many :users\n" }
       it { should contain "belongs_to :resource, :polymorphic => true" }
       it { should contain "field :name, :type => String" }
-      it { should contain "index :name, unique: true" }
-      it { should contain "  index(\n"
-                          "    [\n"
-                          "      [:name, Mongo::ASCENDING],\n"
-                          "      [:resource_type, Mongo::ASCENDING],\n"
-                          "      [:resource_id, Mongo::ASCENDING]\n"
-                          "    ],\n"
-                          "    unique: true\n"
-                          "  )\n" }
+      it { should contain "index({ :name => 1 }, { :unique => true })" }
+      it { should contain "  index({\n"
+                          "      { :name => 1 },\n"
+                          "      { :resource_type => 1 },\n"
+                          "      { :resource_id => 1 }\n"
+                          "    },\n"
+                          "    { unique => true })"}
     end
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "rolify" }
+      it { should contain /class User\n  include Mongoid::Document\n  rolify\n/ }
     end
   end
 end

data/spec/rolify/custom_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 require "rolify/shared_examples/shared_examples_for_roles"
 require "rolify/shared_examples/shared_examples_for_dynamic"
+require "rolify/shared_examples/shared_examples_for_scopes"
+require "rolify/shared_examples/shared_examples_for_callbacks"  
 
 describe "Using Rolify with custom User and Role class names" do
   it_behaves_like Rolify::Role do
@@ -8,8 +10,18 @@ describe "Using Rolify with custom User and Role class names" do
     let(:role_class) { Privilege }
   end
 
+  it_behaves_like "Role.scopes" do
+    let(:user_class) { Customer } 
+    let(:role_class) { Privilege }
+  end
+
   it_behaves_like Rolify::Dynamic do
     let(:user_class) { Customer } 
     let(:role_class) { Privilege }
   end
+
+  it_behaves_like "Rolify.callbacks" do
+    let(:user_class) { Customer }
+    let(:role_class) { Privilege }
+  end
 end

data/spec/rolify/resource_spec.rb

@@ -16,6 +16,7 @@ describe Rolify::Resource do
   let!(:forum_role)      { admin.add_role(:forum, Forum.first) }
   let!(:godfather_role)  { admin.add_role(:godfather, Forum) }
   let!(:group_role)      { admin.add_role(:group, Group.last) }
+  let!(:grouper_role)    { admin.add_role(:grouper, Group.first) }
   let!(:tourist_role)    { tourist.add_role(:forum, Forum.last) }
   let!(:sneaky_role)     { tourist.add_role(:group, Forum.first) }
 
@@ -47,6 +48,15 @@ describe Rolify::Resource do
 
     end
 
+    context "with an array of role names as argument" do 
+      context "on the Group class" do 
+        subject { Group }
+        it "should include Group instances with both group and grouper roles" do 
+          subject.with_roles([:group, :grouper]).should include(Group.first, Group.last)
+        end
+      end
+    end
+
     context "with a role name and a user as arguments" do
       context "on the Forum class" do 
         subject { Forum }
@@ -88,6 +98,27 @@ describe Rolify::Resource do
         end
       end
     end
+
+    context "with an array of role names and a user as arguments" do
+      context "on the Forum class" do 
+        subject { Forum }
+
+        it "should get Forum instances binded to the forum and group roles and the tourist user" do
+          subject.with_roles([:forum, :group], tourist).should include(Forum.first, Forum.last)
+        end
+
+      end
+
+      context "on the Group class" do 
+        subject { Group }
+
+        it "should get Group instances binded to the group and grouper roles and the admin user" do
+          subject.with_roles([:group, :grouper], admin).should include(Group.first, Group.last)
+        end
+
+      end
+    end
+
   end
 
   describe ".find_role" do

data/spec/rolify/role_spec.rb

@@ -1,6 +1,8 @@
 require "spec_helper"
 require "rolify/shared_examples/shared_examples_for_roles"
 require "rolify/shared_examples/shared_examples_for_dynamic"
+require "rolify/shared_examples/shared_examples_for_scopes"
+require "rolify/shared_examples/shared_examples_for_callbacks"
 
 describe Rolify do
   it_behaves_like Rolify::Role do
@@ -8,8 +10,18 @@ describe Rolify do
     let(:role_class) { Role }
   end
 
+  it_behaves_like "Role.scopes" do
+    let(:user_class) { User } 
+    let(:role_class) { Role }
+  end
+
   it_behaves_like Rolify::Dynamic do
     let(:user_class) { User } 
     let(:role_class) { Role }
   end
+
+  it_behaves_like "Rolify.callbacks" do
+    let(:user_class) { User }
+    let(:role_class) { Role }
+  end
 end

data/spec/rolify/shared_contexts.rb

@@ -63,6 +63,18 @@ shared_context "instance scoped role", :scope => :instance do
   end
 end
 
+shared_context "mixed scoped roles", :scope => :mixed do
+  subject { user_class }
+  
+  before(:all) do
+    role_class.destroy_all
+  end
+    
+  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 ]]) }
+end
+
 def create_other_roles
   role_class.create :name => "superhero"
   role_class.create :name => "admin", :resource_type => "Group"

data/spec/rolify/shared_examples/shared_examples_for_callbacks.rb

@@ -0,0 +1,57 @@
+shared_examples_for "Rolify.callbacks" do
+  before(:all) do
+    reset_defaults
+    Rolify.dynamic_shortcuts = false
+    role_class.destroy_all
+  end
+
+  after :each do
+    @user.roles.destroy_all
+  end
+
+  describe "rolify association callbacks", :if => (Rolify.orm == "active_record") do
+    describe "before_add" do
+      it "should receive callback" do
+        user_class.rolify :before_add => :role_callback, :role_cname => role_class.to_s
+        @user = user_class.first
+        @user.stub(:role_callback)
+        @user.should_receive(:role_callback)
+        @user.add_role :admin
+      end
+    end
+
+    describe "after_add" do
+      it "should receive callback" do
+        user_class.rolify :after_add => :role_callback, :role_cname => role_class.to_s
+        @user = user_class.first
+        @user.stub(:role_callback)
+        @user.should_receive(:role_callback)
+        @user.add_role :admin
+      end
+    end
+
+    describe "before_remove" do
+      it "should receive callback" do
+        user_class.rolify :before_remove => :role_callback, :role_cname => role_class.to_s
+        @user = user_class.first
+        @user.add_role :admin
+        @user.stub(:role_callback)
+
+        @user.should_receive(:role_callback)
+        @user.remove_role :admin
+      end
+    end
+
+    describe "after_remove" do
+      it "should receive callback" do
+        user_class.rolify :after_remove => :role_callback, :role_cname => role_class.to_s
+        @user = user_class.first
+        @user.add_role :admin
+        @user.stub(:role_callback)
+
+        @user.should_receive(:role_callback)
+        @user.remove_role :admin
+      end
+    end
+  end
+end

data/spec/rolify/shared_examples/shared_examples_for_finders.rb

@@ -0,0 +1,77 @@
+shared_examples_for :finders do |param_name, param_method|
+  context "using #{param_name} as parameter" do
+    describe ".with_role" do
+      it { should respond_to(:with_role).with(1).argument }
+      it { should respond_to(:with_role).with(2).arguments }
+
+      context "with a global role" do
+        it { subject.with_role("admin".send(param_method)).should eq([ root ]) }
+        it { subject.with_role("moderator".send(param_method)).should be_empty }
+        it { subject.with_role("visitor".send(param_method)).should be_empty }
+      end
+
+      context "with a class scoped role" do
+        context "on Forum class" do
+          it { subject.with_role("admin".send(param_method), Forum).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum).should be_empty }
+        end
+
+        context "on Group class" do
+          it { subject.with_role("admin".send(param_method), Group).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Group).should eq([ root ]) }
+          it { subject.with_role("visitor".send(param_method), Group).should be_empty }
+        end
+      end
+
+      context "with an instance scoped role" do
+        context "on Forum.first instance" do
+          it { subject.with_role("admin".send(param_method), Forum.first).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum.first).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum.first).should be_empty }
+        end
+
+        context "on Forum.last instance" do
+          it { subject.with_role("admin".send(param_method), Forum.last).should eq([ root ]) }
+          it { subject.with_role("moderator".send(param_method), Forum.last).should eq([ modo ]) }
+          it { subject.with_role("visitor".send(param_method), Forum.last).should include(root, visitor) } # =~ doesn't pass using mongoid, don't know why...
+        end
+
+        context "on Group.first instance" do
+          it { subject.with_role("admin".send(param_method), Group.first).should eq([ root ]) }
+          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
+      end
+    end
+
+    describe ".with_all_roles" do
+      it { should respond_to(:with_all_roles) }
+
+      it { subject.with_all_roles("admin".send(param_method), :staff).should eq([ root ]) }
+      it { subject.with_all_roles("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_all_roles("admin".send(param_method), "moderator".send(param_method)).should be_empty }
+      it { subject.with_all_roles("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Forum }).should be_empty }
+      it { subject.with_all_roles({ :name => "moderator".send(param_method), :resource => Forum }, { :name => :manager, :resource => Group }).should eq([ modo ]) }
+      it { subject.with_all_roles("moderator".send(param_method), :manager).should be_empty }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => Forum.last }, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => Group.first }, { :name => "moderator".send(param_method), :resource => Forum }).should eq([ modo ]) }
+      it { subject.with_all_roles({ :name => "visitor".send(param_method), :resource => :any }, { :name => "moderator".send(param_method), :resource => :any }).should =~ [ root, modo ] }
+    end
+
+    describe ".with_any_role" do
+      it { should respond_to(:with_any_role) }
+
+      it { subject.with_any_role("admin".send(param_method), :staff).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Group }).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), "moderator".send(param_method)).should eq([ root ]) }
+      it { subject.with_any_role("admin".send(param_method), :staff, { :name => "moderator".send(param_method), :resource => Forum }).should =~ [ root, modo ] }
+      it { subject.with_any_role({ :name => "moderator".send(param_method), :resource => Forum }, { :name => :manager, :resource => Group }).should eq([ modo ]) }
+      it { subject.with_any_role({ :name => "moderator".send(param_method), :resource => Group }, { :name => :manager, :resource => Group }).should =~ [ root, modo ] }
+      it { subject.with_any_role("moderator".send(param_method), :manager).should be_empty }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => Forum.last }, { :name => "moderator".send(param_method), :resource => Group }).should =~ [ root, visitor ] }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => Group.first }, { :name => "moderator".send(param_method), :resource => Forum }).should eq([ modo ]) }
+      it { subject.with_any_role({ :name => "visitor".send(param_method), :resource => :any }, { :name => "moderator".send(param_method), :resource => :any }).should =~ [ root, modo, visitor ] }
+    end
+  end
+end