rolify 0.5.1 → 0.6.0

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+= 0.6
+* 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
 

data/README.rdoc

@@ -11,7 +11,7 @@ This library was intended to be used with CanCan[https://github.com/ryanb/cancan
 
 == Requirements
 
-* >= Rails 3.1 (rc1 is currently out)
+* >= Rails 3.1 (rc3 is currently out)
 * ActiveRecord ORM
 
 == Installation
@@ -91,6 +91,6 @@ If you have any issue or feature request with/for rolify, please add an {issue o
 
 == TODO
 
-* put syntactic sugar:
-  * <tt>is_admin?</tt> and <tt>is_admin_of?(resource)</tt> like shortcuts
 * write a tutorial showing how to use rolify with CanCan and devise
+* complete tests coverage
+* performance enhancements

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

@@ -12,11 +12,11 @@ module Rolify
       desc "Generates a model with the given NAME and a migration file."
 
       def generate_role
-        template "role.rb", "app/models/role.rb"
+        template "role.rb", "app/models/#{role_cname.downcase}.rb"
         inject_into_class(model_path, user_cname.camelize) do
           "  include Rolify::Roles\n" + 
           "  extend Rolify::Reloaded\n" + 
-          "  has_and_belongs_to_many :roles, :class_name => \"#{role_cname.camelize}\"\n"
+          "  has_and_belongs_to_many :roles#{", :class_name => \"" + role_cname.camelize + "\"" if role_cname != "Role"}, :join_table => :#{user_cname.tableize + "_" + role_cname.tableize}\n"
         end
       end
 

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

@@ -1 +1,2 @@
-<%= user_cname.camelize %>.load_dynamic_methods
+Rolify.user_cname = <%= user_cname.camelize %>
+Rolify.role_cname = <%= role_cname.camelize %>

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

@@ -1,15 +1,19 @@
-class RolifyCreate<%= role_cname.camelize %> < ActiveRecord::Migration
+class RolifyCreate<%= role_cname.pluralize.camelize %> < ActiveRecord::Migration
   def change
-    create_table(<%= role_cname.tableize.to_sym %>) do |t|
+    create_table(:<%= role_cname.tableize %>) do |t|
       t.string :name
       t.references :resource, :polymorphic => true
 
       t.timestamps
     end
 
-    create_table(<%= (user_cname.tableize + "_" + role_cname.tableize).to_sym %>, :id => false) do |t|
+    create_table(:<%= (user_cname.tableize + "_" + role_cname.tableize) %>, :id => false) do |t|
       t.references :<%= user_cname.underscore.singularize %>
       t.references :<%= role_cname.underscore.singularize %>
     end
+
+    add_index(:<%= role_cname.tableize %>, :name)
+    add_index(:<%= role_cname.tableize %>, [ :name, :resource_type, :resource_id ])
+    add_index(:<%= "#{user_cname.tableize}_#{role_cname.tableize}" %>, [ :<%= user_cname.underscore.singularize %>_id, :<%= role_cname.underscore.singularize %>_id ])
   end
 end

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

@@ -1,4 +1,4 @@
 class <%= role_cname.camelize %> < ActiveRecord::Base
-  has_and_belongs_to_many :<%= user_cname.tableize %>
+  has_and_belongs_to_many :<%= user_cname.tableize %>, :join_table => :<%= "#{user_cname.tableize}_#{role_cname.tableize}" %>
   belongs_to :resource, :polymorphic => true
 end

data/lib/rolify.rb

@@ -1,3 +1,5 @@
 require 'active_record'
 
 require 'rolify/role'
+require 'rolify/rolify_railtie.rb' if defined?(Rails)
+

data/lib/rolify/role.rb

@@ -1,11 +1,28 @@
 module Rolify
 
+  def self.role_cname
+    @@role_cname
+  end
+
+  def self.role_cname=(role_cname)
+    @@role_cname = role_cname
+  end
+
+  def self.user_cname
+    @@user_cname
+  end
+
+  def self.user_cname=(user_cname)
+    @@user_cname = user_cname
+  end
+
+
   module Roles
 
     def has_role(role_name, resource = nil)
-      role = Role.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.class.name if resource), 
+                                                                                  :resource_id => (resource.id if resource))
       if !roles.include?(role)
         self.class.define_dynamic_method role_name, resource
         self.roles << role
@@ -50,7 +67,7 @@ module Rolify
     end
   
     def has_no_role(role_name, resource = nil)
-      role = Role.where( :name => role_name)
+      role = self.roles.where( :name => role_name)
       role = role.where( :resource_type => resource.class.name,
                          :resource_id => resource.id) if resource
       self.roles.delete(role) if role
@@ -78,7 +95,7 @@ module Rolify
   module Reloaded
  
     def load_dynamic_methods
-      Role.all.each do |r|
+      Rolify.role_cname.all.each do |r|
         define_dynamic_method(r.name, r.resource)
       end
     end

data/lib/rolify/rolify_railtie.rb

@@ -0,0 +1,9 @@
+module Rolify
+  class RoleRailtie < ::Rails::Railtie
+    initializer "instantiate roles methods" do
+      ActiveSupport.on_load :active_record do
+        Rolify.user_cname.load_dynamic_methods if defined? Rails.server
+      end
+    end
+  end
+end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/spec/rolify/role_spec.rb

@@ -1,235 +1,254 @@
 require "spec_helper"
 
-describe Rolify do
-  context "in a Instance level" do 
-    before(:all) do
-      @admin = User.first
-      @admin.has_role "admin"
-      @admin.has_role "moderator", Forum.first
-    end
+shared_examples_for "Rolify module" do
+    context "in a Instance level" do 
+      before(:all) do
+        Rolify.user_cname = user_cname
+        Rolify.role_cname = role_cname
+        @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_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_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 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" do
-      @admin.should respond_to(:is_admin?).with(0).arguments
-      @admin.should respond_to(:is_moderator_of?).with(1).arguments
-    end
+      it "should respond to dynamic methods" 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" do
-      @admin.should_not respond_to(:is_god?)
+      it "should not respond to any unknown methods" do
+        @admin.should_not respond_to(:is_god?)
+      end
     end
-  end
 
-  context "with a global role" do 
-    before(:all) do
-      @admin = User.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{ Role.count }.by(1)
-      superadmin = Role.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{ Role.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
+    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
 
-    it "should be able to use dynamic shortcut" 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
-      Role.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 be able to use dynamic shortcut" 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_role?("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 all of a global roles set" do
+        @admin.has_role?("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?("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 }
+      it "should check if user has any of a global roles set" do
+        @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
     end
-  end
   
-  context "with a scoped role" do
-    before(:all) do
-      @moderator = User.find(2)
-      @moderator.has_role "moderator", Forum.first
-      @moderator.has_role "soldier"
-    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{ Role.count }.by(1)
-      supermodo = Role.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{ Role.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 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" 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 be able to use dynamic shortcut" 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
-      Role.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
-      Role.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 => "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 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 => "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 => "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)
+      it "should check if user has any of a scoped roles set" do
+        @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
-    
-    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 different roles" do 
-    before(:all) do 
-      @user = User.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)
+    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 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?("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?("dummy", { :name => "dumber", :resource => Forum.last }).should be(false)
+      end
     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?("dummy", { :name => "dumber", :resource => Forum.last }).should be(false)
+
+end
+
+describe Rolify do
+  context "using default Role and User class names" do 
+    it_behaves_like "Rolify module" do
+      let(:user_cname) { User } 
+      let(:role_cname) { Role }
     end
+ 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?("dummy", { :name => "dumber", :resource => Forum.last }).should be(false)
+  context "using custom User and Role class names" do 
+    it_behaves_like "Rolify module" do
+      let(:user_cname) { Customer }
+      let(:role_cname) { Privilege }
     end
   end
 end

data/spec/support/data.rb

@@ -3,4 +3,7 @@ User.create(:login => "moderator")
 User.create(:login => "god")
 Forum.create(:name => "forum 1")
 Forum.create(:name => "forum 2")
-Forum.create(:name => "forum 3")
+Forum.create(:name => "forum 3")
+
+Customer.create(:login => "customer VIP")
+Customer.create(:login => "customer Doe")

data/spec/support/models.rb

@@ -11,3 +11,15 @@ end
 
 class Forum < ActiveRecord::Base
 end
+
+class Customer < ActiveRecord::Base
+  has_and_belongs_to_many :roles, :join_table => :customers_privileges, :class_name => "Privilege"
+  include Rolify::Roles
+  extend Rolify::Reloaded
+end
+
+class Privilege < ActiveRecord::Base
+  has_and_belongs_to_many :customers, :join_table => :customers_privileges
+  belongs_to :resource, :polymorphic => true
+end
+

data/spec/support/schema.rb

@@ -20,4 +20,18 @@ ActiveRecord::Schema.define do
   create_table(:forums) do |t|
     t.string :name
   end
-end
+
+  create_table(:privileges) do |t|
+    t.string :name
+    t.references :resource, :polymorphic => true
+  end
+
+  create_table(:customers) do |t|
+    t.string :login
+  end
+
+  create_table(:customers_privileges, :id => false) do |t|
+    t.references :customer
+    t.references :privilege
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: rolify
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - Florent Monbillard
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-07 00:00:00 Z
+date: 2011-06-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sqlite3
@@ -56,6 +56,7 @@ files:
 - lib/generators/rolify/role/templates/role.rb
 - lib/rolify.rb
 - lib/rolify/role.rb
+- lib/rolify/rolify_railtie.rb
 - lib/rolify/version.rb
 - rolify.gemspec
 - spec/rolify/role_spec.rb