can-has-permission 0.0.2 → 0.1.0

data/generators/can_has_permission_generator.rb

@@ -0,0 +1,17 @@
+require 'rails_generator'
+class CanHasPermissionGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template "can_has_permission_create_anonymous.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_anonymous" }
+      m.migration_template "can_has_permission_create_permissions.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_permissions" }
+      m.migration_template "can_has_permission_create_role_types.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_role_types" }
+      m.migration_template "can_has_permission_create_permission_types.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_permission_types" }
+      m.migration_template "can_has_permission_create_roles.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_roles" }
+    end
+  end
+end

data/generators/templates/can_has_permission_create_anonymous.rb

@@ -0,0 +1,14 @@
+class CanHasPermissionCreateAnonymous< ActiveRecord::Migration
+  def self.up
+    create_table :anonymous do |t|
+      t.string :name, :null => false
+      t.timestamps
+    end
+    add_index :anonymous, :name, :unique => true
+  end
+
+  def self.down
+    add_index :anonymous, :name, :unique => true
+    drop_table :anonymous
+  end
+end

data/generators/templates/can_has_permission_create_permission_types.rb

@@ -0,0 +1,14 @@
+class CanHasPermissionCreatePermissionTypes < ActiveRecord::Migration
+  def self.up
+    create_table :permission_types do |t|
+      t.string :name, :null => false
+      t.timestamps
+    end
+    add_index :permission_types, :name, :unique => true
+  end
+
+  def self.down
+    remove_index :permission_types, :name
+    drop_table :permission_types
+  end
+end

data/generators/templates/can_has_permission_create_permissions.rb

@@ -0,0 +1,18 @@
+class CanHasPermissionCreatePermissions < ActiveRecord::Migration
+  def self.up
+    create_table :permissions do |t|
+      t.string :permissible_type, :null => false
+      t.integer :permissible_id, :null => false
+      t.integer :permission_type_id, :null => false
+      t.timestamps
+    end
+    add_index :permissions, :permission_type_id
+    add_index :permissions, [:permissible_id, :permissible_type]
+  end
+
+  def self.down
+    remove_index :permissions, :permission_type_id
+    remove_index :permissions, [:permissible_id, :permissible_type]
+    drop_table :permissions
+  end
+end

data/generators/templates/can_has_permission_create_role_types.rb

@@ -0,0 +1,14 @@
+class CanHasPermissionCreateRoleTypes < ActiveRecord::Migration
+  def self.up
+    create_table :role_types do |t|
+      t.string :name, :null => false
+      t.timestamps
+    end
+    add_index :role_types, :name, :unique => true
+  end
+
+  def self.down
+    remove_index :role_types, :name
+    drop_table :role_types
+  end
+end

data/generators/templates/can_has_permission_create_roles.rb

@@ -0,0 +1,18 @@
+class CanHasPermissionCreateRoles < ActiveRecord::Migration
+  def self.up
+    create_table :roles do |t|
+      t.string :permissible_type, :null => false
+      t.integer :permissible_id, :null => false
+      t.integer :role_type_id, :null => false
+      t.timestamps
+    end
+    add_index :roles, :role_type_id
+    add_index :roles, [:permissible_id, :permissible_type]
+  end
+
+  def self.down
+    remove_index :roles, :role_type_id
+    remove_index :roles, [:permissible_id, :permissible_type]
+    drop_table :roles
+  end
+end

data/lib/can-has-permission.rb

@@ -1,56 +1,29 @@
 module CanHasPermission
-  def can
-    CanHasPermission::HasPermission.find(:all, :conditions => { :model => self.class.to_s, :model_id => self.id}).collect{|has_perm| has_perm.permission}
-  end
-  
-  def can?(permission)
-    role_ids = []
-    CanHasPermission::HasRole.find(:all, :conditions => { :model => self.class.to_s, :model_id => self.id}).each do |role|
-      role_ids << role.id
-    end
-    CanHasPermission::HasPermission.find(:first,:include=>[:permission_class], :conditions => ['((model =? and model_id =? ) or (model=? and model_id in (?) ))and permissions.name=?',self.class.to_s, self.id,CanHasPermission::Role.to_s,role_ids, permission.to_s]) != nil
-  end
   
-  def can=(permission_list)
-    permission_list = [permission_list] unless permission_list.respond_to?(:each)
-    permission_list.each do |permission|
-      #if database is down then catestrophic error
-      CanHasPermission::HasPermission.create!(:permission =>permission.to_s, :model => self.class.to_s, :model_id => self.id) unless self.can?(permission)
+  def self.included(base)
+    base.class_eval do
+      has_many :roles, :as => 'permissible', :class_name => 'CanHasPermission::Role'
+      has_many :permissions, :as => 'permissible', :class_name => 'CanHasPermission::Permission'
+      accepts_nested_attributes_for :permissions
+      accepts_nested_attributes_for :roles
     end
   end
   
-  def can_not(permission_list)
-    permission_list = [permission_list] unless permission_list.respond_to?(:each)
-    CanHasPermission::HasPermission.find(:all,:include=>[:permission_class], :conditions => ['model =? and model_id =? and permissions.name in (?)',self.class.to_s, self.id, permission_list.collect{|p| p.to_s}]).each do |has_permission|
-      has_permission.destroy
+  def can?(permission)
+    return true if (!self.permissions.select{|p| p.name == permission.to_s}.empty?)
+    self.roles.each do |role|
+      return true if role.role_type.can?(permission)
     end
+    false
   end
-  
+
   def has_role?(role)
-    CanHasPermission::HasRole.find(:first,:include=>[:role_class], :conditions => ['model =? and model_id =? and roles.name=?',self.class.to_s, self.id, role.to_s]) != nil
-  end
-  
-  def roles
-    CanHasPermission::HasRole.find(:all, :conditions => { :model => self.class.to_s, :model_id => self.id}).collect{|has_role| has_role.role}
-  end
-  
-  def add_roles(role_list)
-    role_list = [role_list] unless role_list.respond_to?(:each)
-    role_list.each do |role|
-      #if database is down then catestrophic error
-      CanHasPermission::HasRole.create!(:role =>role.to_s, :model => self.class.to_s, :model_id => self.id) unless self.has_role?(role)
-    end
-  end
-  
-  def remove_roles(role_list)
-    role_list = [role_list] unless role_list.respond_to?(:each)
-    CanHasPermission::HasRole.find(:all,:include=>[:role_class], :conditions => ['model =? and model_id =? and roles.name in (?)',self.class.to_s, self.id, role_list.collect{|p| p.to_s}]).each do |has_role|
-      has_role.destroy
-    end
+    !self.roles.select{|r| r.name == role.to_s}.empty?
   end
 end
 
-require File.join(File.dirname(__FILE__), 'can-has-permission', 'has_permission')
 require File.join(File.dirname(__FILE__), 'can-has-permission', 'permission')
+require File.join(File.dirname(__FILE__), 'can-has-permission', 'permission_type')
 require File.join(File.dirname(__FILE__), 'can-has-permission', 'role')
-require File.join(File.dirname(__FILE__), 'can-has-permission', 'has_role')
+require File.join(File.dirname(__FILE__), 'can-has-permission', 'role_type')
+require File.join(File.dirname(__FILE__), 'can-has-permission', 'anonymous')

data/lib/can-has-permission/anonymous.rb

@@ -0,0 +1,7 @@
+module CanHasPermission
+  class Anonymous < ActiveRecord::Base
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    include CanHasPermission
+  end
+end

data/lib/can-has-permission/permission.rb

@@ -1,4 +1,27 @@
-class CanHasPermission::Permission < ActiveRecord::Base
-  validates_presence_of :name
-  validates_uniqueness_of :name
+module CanHasPermission
+  class Permission < ActiveRecord::Base
+    validates_presence_of :permission_type_id, :if => lambda{|instance| instance.name.blank?}
+    validates_presence_of :permissible_id
+    validates_presence_of :permissible_type
+    validates_uniqueness_of :permissible_type, :permissible_id, :scope => :permissible_id
+    before_save :create_permission, :unless => lambda{|instance| instance.name.blank?}
+  
+    belongs_to :permissible, :polymorphic => true
+    belongs_to :permission_type, :class_name => 'CanHasPermission::PermissionType'
+    
+    def name=(permission)
+      @permission = permission.to_s
+    end
+  
+    #test this
+    def name
+      @permission || permission_type.try(:name)
+    end
+  
+    protected
+  
+    def create_permission
+      self.permission_type_id = CanHasPermission::PermissionType.find_or_create_by_name(:name => self.name).id
+    end
+  end
 end

data/lib/can-has-permission/permission_type.rb

@@ -0,0 +1,7 @@
+module CanHasPermission
+  class PermissionType < ActiveRecord::Base
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    has_many :permissions, :class_name => 'CanHasPermission::Permission'
+  end
+end

data/lib/can-has-permission/role.rb

@@ -1,5 +1,25 @@
-class CanHasPermission::Role < ActiveRecord::Base
-  include CanHasPermission
-  validates_presence_of :name
-  validates_uniqueness_of :name
+module CanHasPermission
+  class Role < ActiveRecord::Base
+    validates_presence_of :role_type_id, :if => lambda{|instance| instance.name.blank?}
+    validates_presence_of :permissible_id
+    validates_presence_of :permissible_type
+    validates_uniqueness_of :permissible_type, :permissible_id, :scope => :permissible_id
+    before_save :create_role, :unless => lambda{|instance| instance.name.blank?}
+  
+    belongs_to :permissible, :polymorphic => true
+    belongs_to :role_type, :class_name => 'CanHasPermission::RoleType'
+  
+    def name=(role)
+      @role = role.to_s
+    end
+  
+    def name
+      @role || role_type.try(:name)
+    end
+  
+    protected
+    def create_role
+      self.role_type_id = CanHasPermission::RoleType.find_or_create_by_name(:name => self.name).id
+    end
+  end
 end

data/lib/can-has-permission/role_type.rb

@@ -0,0 +1,14 @@
+module CanHasPermission
+  class RoleType < ActiveRecord::Base
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    has_many :roles, :class_name => 'CanHasPermission::Role'
+    has_many :permissions, :as => 'permissible', :class_name => 'CanHasPermission::Permission'
+    accepts_nested_attributes_for :permissions
+    
+    def can?(permission)
+      return true if (!self.permissions.select{|p| p.name == permission.to_s}.empty?)
+      false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,31 +4,35 @@ require 'can-has-permission'
 require 'rubygems'
 require 'ruby-debug'
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
 def reset_database
   ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
   ActiveRecord::Schema.define(:version => 1) do
-    create_table :roles do |t|
+    create_table :role_types do |t|
       t.string :name, :null => false
       t.timestamps
     end
     
-    create_table :permissions do |t|
+    create_table :anonymous do |t|
+      t.string :name, :null => false
+      t.timestamps
+    end
+    
+    create_table :permission_types do |t|
       t.string :name, :null => false
       t.timestamps
     end
     
-    create_table :has_roles do |t|
-      t.string :model, :null => false
-      t.integer :model_id, :null => false
-      t.integer :role_id, :null => false
+    create_table :roles do |t|
+      t.string :permissible_type, :null => false
+      t.integer :permissible_id, :null => false
+      t.integer :role_type_id, :null => false
       t.timestamps
     end
-    create_table :has_permissions do |t|
-      t.string :model, :null => false
-      t.integer :model_id, :null => false
-      t.integer :permission_id, :null => false
+    
+    create_table :permissions do |t|
+      t.string :permissible_type, :null => false
+      t.integer :permissible_id, :null => false
+      t.integer :permission_type_id, :null => false
       t.timestamps
     end
   end

data/spec/tests/anonymous_spec.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe CanHasPermission::Anonymous do
+  it "created with a name should be valid" do
+    CanHasPermission::Anonymous.find_or_create_by_name('name').should be_valid
+  end
+  
+  it "created without a name should not be valid" do
+    CanHasPermission::Anonymous.new().should be_invalid
+  end
+  
+  it "created with an already used name should not be valid" do
+    CanHasPermission::Anonymous.create!(:name => 'name')
+    CanHasPermission::Anonymous.new(:name => 'name').should be_invalid
+  end
+  
+  describe "creating an anonymous with permissions" do
+    before(:each) do
+      @role = CanHasPermission::Anonymous.create!(:name => 'user')
+      @role.permissions.create!(:name => 'perm')
+      @role.reload
+    end
+    it "should have an attached permission" do
+      @role.permissions.should_not be_empty
+    end
+    describe "#can?" do
+      it "should return true when given the permission" do
+        @role.can?(:perm).should be_true
+      end
+      it "should return false when given a different permission" do
+        @role.can?(:perm2).should be_false
+      end
+    end
+  end
+  
+  describe "creating an anonymous with roles" do
+    before(:each) do
+      @role = CanHasPermission::Anonymous.create!(:name => 'user')
+      @role.roles.create!(:name => 'perm')
+      @role.reload
+    end
+    it "should have an attached role" do
+      @role.roles.should_not be_empty
+    end
+    describe "#has_role?" do
+      it "should return true when given the role" do
+        @role.has_role?(:perm).should be_true
+      end
+      it "should return false when given a different role" do
+        @role.has_role?(:perm2).should be_false
+      end
+    end
+  end
+  describe "creating a role_type with permissions" do
+    before(:each) do
+      @role_type_name = 'type'
+      @role_type = CanHasPermission::RoleType.create!(:name => @role_type_name)
+      @role_type.permissions.create!(:name => 'perm')
+      @role_type.reload
+    end
+    describe "and adding the role to anon" do
+      before(:each) do
+        @role = CanHasPermission::Anonymous.create!(:name => 'user')
+        @role.roles.create!(:name => @role_type_name)
+      end
+      describe "#can?" do
+        it "should return true when given the permission" do
+          @role.can?(:perm).should be_true
+        end
+        it "should return false when given a different permission" do
+          @role.can?(:perm2).should be_false
+        end
+      end
+    end
+  end
+end

data/spec/tests/permission_spec.rb

@@ -1,20 +1,59 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe CanHasPermission::Permission do
-  it "should be valid with a name" do
-    role = CanHasPermission::Permission.new(:name => 'Bingo')
+  it "created with all attributes should be valid" do
+    role = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
     role.should be_valid
   end
-  it "should not be valid without a name" do
-    role = CanHasPermission::Permission.new()
-    role.should_not be_valid
+  it "should be invalid without a name" do
+    role = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object')
+    role.should be_invalid
   end
-  it "should not be valid when it has a name that already exists" do
-    name = 'the same'
-    role1 = CanHasPermission::Permission.create!(:name => 'the same')
-    role2 = CanHasPermission::Permission.new(:name => 'the same')
-    role1.should be_valid
-    role1.id.should_not be_nil
+  it "two permissions with the same object should not be valid" do
+    role1 = CanHasPermission::Permission.create!(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
+    role2 = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
     role2.should_not be_valid
   end
+  it "two permissions with different object ids should be valid" do
+    role1 = CanHasPermission::Permission.create!(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
+    role2 = CanHasPermission::Permission.new(:permissible_id => 2, :permissible_type => 'Object', :name => 'role')
+    role2.should be_valid
+  end
+  describe "with a role type" do
+    before(:each) do
+      @role_type = CanHasPermission::PermissionType.create!(:name => 'role')
+    end
+    it "should be valid without a name" do
+      role = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object', :name => @role_type)
+      role.should be_valid
+    end
+  end
+  it "should be invalid without a permissible_id" do
+    role = CanHasPermission::Permission.new(:permissible_type => 'Object', :name => 'role')
+    role.should be_invalid
+  end
+  it "should be invalid without a permissible_type" do
+    role = CanHasPermission::Permission.new(:permissible_id => 1, :name => 'role', :name => 'role')
+    role.should be_invalid
+  end
+  describe "created with a name and not a permission" do
+    before(:each) do
+      @role_name = 'role'
+      @role = CanHasPermission::Permission.create!(:permissible_id => 1, :permissible_type => 'Object', :name => @role_name)
+    end
+    it "should create a permission_type" do
+      CanHasPermission::PermissionType.count(:conditions => {:name => @role_name}).should == 1
+    end
+    describe "and another role of the same permission is created" do
+      before(:each) do
+        @role2 = CanHasPermission::Permission.create!(:permissible_id => 2, :permissible_type => 'Object', :name => @role_name)        
+      end
+      it "should not create a second permission_type" do
+        CanHasPermission::PermissionType.count(:conditions => {:name => @role_name}).should == 1        
+      end
+      it "both should have the same permission_type instance" do
+        @role2.permission_type_id.should == @role.permission_type_id
+      end
+    end
+  end
 end