can-has-permission 0.1.0 → 0.2.1

data/generators/can_has_permission_generator.rb

@@ -4,14 +4,14 @@ class CanHasPermissionGenerator < Rails::Generator::Base
     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_permission_maps.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_permission_maps" }
       m.migration_template "can_has_permission_create_roles.rb", "db/migrate",
                             { :migration_file_name => "can_has_permission_create_roles" }
+      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_maps.rb", "db/migrate",
+                            { :migration_file_name => "can_has_permission_create_role_maps" }
     end
   end
 end

data/generators/templates/can_has_permission_create_permission_maps.rb

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

data/generators/templates/can_has_permission_create_role_maps.rb

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

data/lib/action_controller.rb

@@ -0,0 +1,14 @@
+module ActionController
+  module Filters
+    module ClassMethods
+      def requires_permission(permission)
+        before_filter lambda { |instance| 
+          unless instance.send(:current_user).can?(permission)
+            instance.send(:permission_denied, permission)
+            return false
+          end
+        } 
+      end
+    end
+  end
+end

data/lib/can-has-permission.rb

@@ -2,17 +2,19 @@ module CanHasPermission
   
   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
+      has_many :role_maps, :as => 'permissible', :class_name => 'CanHasPermission::RoleMap'
+      has_many :permission_maps, :as => 'permissible', :class_name => 'CanHasPermission::PermissionMap'
+      has_many :permissions, :through => :permission_maps
+      has_many :roles, :through => :role_maps
+      accepts_nested_attributes_for :role_maps
+      accepts_nested_attributes_for :permission_maps
     end
   end
   
   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)
+      return true if role.can?(permission)
     end
     false
   end
@@ -22,8 +24,9 @@ module CanHasPermission
   end
 end
 
+require File.join(File.dirname(__FILE__), 'can-has-permission', 'permission_map')
 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_map')
 require File.join(File.dirname(__FILE__), 'can-has-permission', 'role')
-require File.join(File.dirname(__FILE__), 'can-has-permission', 'role_type')
-require File.join(File.dirname(__FILE__), 'can-has-permission', 'anonymous')
+require File.join(File.dirname(__FILE__), 'can-has-permission', 'anonymous')
+require File.join(File.dirname(__FILE__), 'action_controller')

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

@@ -1,27 +1,7 @@
 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
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    has_many :permission_maps, :class_name => 'CanHasPermission::PermissionMap'
   end
 end

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

@@ -0,0 +1,11 @@
+module CanHasPermission
+  class PermissionMap < ActiveRecord::Base
+    validates_presence_of :permission_id
+    #validates_presence_of :permissible_id
+    #validates_presence_of :permissible_type
+    validates_uniqueness_of :permissible_type, :permissible_id, :scope => :permissible_id
+  
+    belongs_to :permissible, :polymorphic => true
+    belongs_to :permission, :class_name => 'CanHasPermission::Permission'
+  end
+end

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

@@ -1,25 +1,14 @@
 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
+    validates_presence_of :name
+    validates_uniqueness_of :name
+    has_many :role_maps, :class_name => 'CanHasPermission::RoleMap'
+    has_many :permission_maps, :as => 'permissible', :class_name => 'CanHasPermission::PermissionMap'
+    has_many :permissions, :through => :permission_maps
+    
+    def can?(permission)
+      return true if (!self.permissions.select{|p| p.name == permission.to_s}.empty?)
+      false
     end
   end
 end

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

@@ -0,0 +1,11 @@
+module CanHasPermission
+  class RoleMap < ActiveRecord::Base
+    validates_presence_of :role_id
+    #validates_presence_of :permissible_id
+    #validates_presence_of :permissible_type
+    validates_uniqueness_of :permissible_type, :permissible_id, :scope => :permissible_id
+  
+    belongs_to :permissible, :polymorphic => true
+    belongs_to :role, :class_name => 'CanHasPermission::Role'
+  end
+end

data/spec/spec_helper.rb

@@ -7,7 +7,7 @@ require 'ruby-debug'
 def reset_database
   ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
   ActiveRecord::Schema.define(:version => 1) do
-    create_table :role_types do |t|
+    create_table :roles do |t|
       t.string :name, :null => false
       t.timestamps
     end
@@ -17,22 +17,22 @@ def reset_database
       t.timestamps
     end
     
-    create_table :permission_types do |t|
+    create_table :permissions do |t|
       t.string :name, :null => false
       t.timestamps
     end
     
-    create_table :roles do |t|
+    create_table :role_maps do |t|
       t.string :permissible_type, :null => false
       t.integer :permissible_id, :null => false
-      t.integer :role_type_id, :null => false
+      t.integer :role_id, :null => false
       t.timestamps
     end
     
-    create_table :permissions do |t|
+    create_table :permission_maps do |t|
       t.string :permissible_type, :null => false
       t.integer :permissible_id, :null => false
-      t.integer :permission_type_id, :null => false
+      t.integer :permission_id, :null => false
       t.timestamps
     end
   end

data/spec/tests/anonymous_spec.rb

@@ -51,17 +51,18 @@ describe CanHasPermission::Anonymous do
       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 = CanHasPermission::Role.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)
+        @role.role_maps.create!(:role => @role_type)
       end
       describe "#can?" do
         it "should return true when given the permission" do
@@ -73,4 +74,21 @@ describe CanHasPermission::Anonymous do
       end
     end
   end
+  
+  it "using nested attributes should save" do
+    role =CanHasPermission::Role.create!(:name => 'role')
+    anon = CanHasPermission::Anonymous.create(:name => 'user', :role_maps_attributes => [{:role => role}])
+    anon.reload
+    anon.role_maps.should_not be_empty
+    anon.roles.should_not be_empty
+    anon.role_maps.first.permissible_id.should_not be_nil
+  end
+  it "using nested attributes should save" do
+    role =CanHasPermission::Permission.create!(:name => 'role')
+    anon = CanHasPermission::Anonymous.create(:name => 'user', :permission_maps_attributes => [{:permission => role}])
+    anon.reload
+    anon.permission_maps.should_not be_empty
+    anon.permissions.should_not be_empty
+    anon.permission_maps.first.permissible_id.should_not be_nil
+  end
 end

data/spec/tests/permission_map_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe CanHasPermission::PermissionMap do
+  it "created with all attributes should be valid" do
+    role = CanHasPermission::PermissionMap.new(:permissible_id => 1, :permissible_type => 'Object', :permission_id => 1)
+    role.should be_valid
+  end
+  it "should be invalid without an id" do
+    role = CanHasPermission::PermissionMap.new(:permissible_id => 1, :permissible_type => 'Object')
+    role.should be_invalid
+  end
+  it "two permissions with the same object should not be valid" do
+    role1 = CanHasPermission::PermissionMap.create!(:permissible_id => 1, :permissible_type => 'Object', :permission_id => 1)
+    role2 = CanHasPermission::PermissionMap.new(:permissible_id => 1, :permissible_type => 'Object', :permission_id => 1)
+    role2.should_not be_valid
+  end
+  it "two permissions with different object ids should be valid" do
+    role1 = CanHasPermission::PermissionMap.create!(:permissible_id => 1, :permissible_type => 'Object', :permission_id => 1)
+    role2 = CanHasPermission::PermissionMap.new(:permissible_id => 2, :permissible_type => 'Object', :permission_id => 1)
+    role2.should be_valid
+  end
+  it "two permissions with the same object but different roles should be valid" do
+    role1 = CanHasPermission::PermissionMap.create!(:permissible_id => 1, :permissible_type => 'Object', :permission_id => 1)
+    role2 = CanHasPermission::PermissionMap.new(:permissible_id => 2, :permissible_type => 'Object', :permission_id => 2)
+    role2.should be_valid
+  end
+  describe "with a permission" do
+    before(:each) do
+      @role_type = CanHasPermission::Permission.create!(:name => 'role')
+    end
+    it "should be valid without a name" do
+      role = CanHasPermission::PermissionMap.new(:permissible_id => 1, :permissible_type => 'Object', :permission => @role_type)
+      role.should be_valid
+    end
+  end
+
+end

data/spec/tests/permission_spec.rb

@@ -1,59 +1,20 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe CanHasPermission::Permission do
-  it "created with all attributes should be valid" do
-    role = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
+  it "should be valid with a name" do
+    role = CanHasPermission::Permission.new(:name => 'Bingo')
     role.should be_valid
   end
-  it "should be invalid without a name" do
-    role = CanHasPermission::Permission.new(:permissible_id => 1, :permissible_type => 'Object')
-    role.should be_invalid
+  it "should not be valid without a name" do
+    role = CanHasPermission::Permission.new()
+    role.should_not be_valid
   end
-  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')
+  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
     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

data/spec/tests/role_map_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe CanHasPermission::RoleMap do
+  it "created with all attributes should be valid" do
+    role = CanHasPermission::RoleMap.new(:permissible_id => 1, :permissible_type => 'Object', :role_id => 1)
+    role.should be_valid
+  end
+  it "should be invalid without an id" do
+    role = CanHasPermission::RoleMap.new(:permissible_id => 1, :permissible_type => 'Object')
+    role.should be_invalid
+  end
+  it "two permissions with the same object should not be valid" do
+    role1 = CanHasPermission::RoleMap.create!(:permissible_id => 1, :permissible_type => 'Object', :role_id => 1)
+    role2 = CanHasPermission::RoleMap.new(:permissible_id => 1, :permissible_type => 'Object', :role_id => 1)
+    role2.should_not be_valid
+  end
+  it "two permissions with different object ids should be valid" do
+    role1 = CanHasPermission::RoleMap.create!(:permissible_id => 1, :permissible_type => 'Object', :role_id => 1)
+    role2 = CanHasPermission::RoleMap.new(:permissible_id => 2, :permissible_type => 'Object', :role_id => 1)
+    role2.should be_valid
+  end
+  it "two permissions with the same object but different roles should be valid" do
+    role1 = CanHasPermission::RoleMap.create!(:permissible_id => 1, :permissible_type => 'Object', :role_id => 1)
+    role2 = CanHasPermission::RoleMap.new(:permissible_id => 2, :permissible_type => 'Object', :role_id => 2)
+    role2.should be_valid
+  end
+  describe "with a permission" do
+    before(:each) do
+      @role_type = CanHasPermission::Role.create!(:name => 'role')
+    end
+    it "should be valid without a name" do
+      role = CanHasPermission::RoleMap.new(:permissible_id => 1, :permissible_type => 'Object', :role => @role_type)
+      role.should be_valid
+    end
+  end
+
+end

data/spec/tests/role_spec.rb

@@ -1,58 +1,37 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe CanHasPermission::Role do
-  it "created with all attributes should be valid" do
-    role = CanHasPermission::Role.new(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
+  it "should be valid with a name" do
+    role = CanHasPermission::Role.new(:name => 'Bingo')
     role.should be_valid
   end
-  it "should be invalid without a name" do
-    role = CanHasPermission::Role.new(:permissible_id => 1, :permissible_type => 'Object')
-    role.should be_invalid
+  it "should not be valid without a name" do
+    role = CanHasPermission::Role.new()
+    role.should_not be_valid
   end
-  it "two roles with the same object and role should not be valid" do
-    role1 = CanHasPermission::Role.create!(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
-    role2 = CanHasPermission::Role.new(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
+  it "should not be valid when it has a name that already exists" do
+    name = 'the same'
+    role1 = CanHasPermission::Role.create!(:name => 'the same')
+    role2 = CanHasPermission::Role.new(:name => 'the same')
+    role1.should be_valid
+    role1.id.should_not be_nil
     role2.should_not be_valid
   end
-  it "two roles with the same object should be valid" do
-    role1 = CanHasPermission::Role.create!(:permissible_id => 1, :permissible_type => 'Object', :name => 'role')
-    role2 = CanHasPermission::Role.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::RoleType.create!(:name => 'role')
-    end
-    it "should be valid without a name" do
-      role = CanHasPermission::Role.new(:permissible_id => 1, :permissible_type => 'Object', :role_type => @role_type)
-      role.should be_valid
-    end
-  end
-  it "should be invalid without a permissible_id" do
-    role = CanHasPermission::Role.new(:permissible_type => 'Object', :name => 'role')
-    role.should be_invalid
-  end
-  it "should be invalid without a permissible_type" do
-    role = CanHasPermission::Role.new(:permissible_id => 1, :name => 'role', :name => 'role')
-    role.should be_invalid
-  end
-  describe "created with a name and not a type" do
+  describe "creating a role_type with permissions" do
     before(:each) do
-      @role_name = 'role'
-      @role = CanHasPermission::Role.create!(:permissible_id => 1, :permissible_type => 'Object', :name => @role_name)
+      @role = CanHasPermission::Role.create!(:name => 'joe')
+      @role.permissions.create!(:name => 'perm')
+      @role.reload
     end
-    it "should create a role_type" do
-      CanHasPermission::RoleType.count(:conditions => {:name => @role_name}).should == 1
+    it "should have an attached permission" do
+      @role.permissions.should_not be_empty
     end
-    describe "and another role of the same type is created" do
-      before(:each) do
-        @role2 = CanHasPermission::Role.create!(:permissible_id => 2, :permissible_type => 'Object', :name => @role_name)        
-      end
-      it "should not create a second role_type" do
-        CanHasPermission::RoleType.count(:conditions => {:name => @role_name}).should == 1        
+    describe "#can?" do
+      it "should return true when given the permission" do
+        @role.can?(:perm).should be_true
       end
-      it "both should have the same role_type instance" do
-        @role2.role_type_id.should == @role.role_type_id
+      it "should return false when given a different permission" do
+        @role.can?(:perm2).should be_false
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: can-has-permission
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 21
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 0
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Chris Rode
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-25 00:00:00 +01:00
+date: 2010-08-26 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -30,23 +30,22 @@ extra_rdoc_files:
 files: 
 - generators/can_has_permission_generator.rb
 - generators/templates/can_has_permission_create_anonymous.rb
-- generators/templates/can_has_permission_create_permission_types.rb
-- generators/templates/can_has_permission_create_permissions.rb
-- generators/templates/can_has_permission_create_role_types.rb
-- generators/templates/can_has_permission_create_roles.rb
+- generators/templates/can_has_permission_create_permission_maps.rb
+- generators/templates/can_has_permission_create_role_maps.rb
+- lib/action_controller.rb
 - lib/can-has-permission.rb
 - lib/can-has-permission/anonymous.rb
 - lib/can-has-permission/permission.rb
-- lib/can-has-permission/permission_type.rb
+- lib/can-has-permission/permission_map.rb
 - lib/can-has-permission/role.rb
-- lib/can-has-permission/role_type.rb
+- lib/can-has-permission/role_map.rb
 - README.rdoc
 - spec/spec_helper.rb
 - spec/tests/anonymous_spec.rb
+- spec/tests/permission_map_spec.rb
 - spec/tests/permission_spec.rb
-- spec/tests/permission_type_spec.rb
+- spec/tests/role_map_spec.rb
 - spec/tests/role_spec.rb
-- spec/tests/role_type_spec.rb
 has_rdoc: true
 homepage: http://github.com/cirode/can-has-permission
 licenses: []
@@ -84,7 +83,7 @@ summary: simple permissions based authorisation
 test_files: 
 - spec/spec_helper.rb
 - spec/tests/anonymous_spec.rb
+- spec/tests/permission_map_spec.rb
 - spec/tests/permission_spec.rb
-- spec/tests/permission_type_spec.rb
+- spec/tests/role_map_spec.rb
 - spec/tests/role_spec.rb
-- spec/tests/role_type_spec.rb

data/generators/templates/can_has_permission_create_permission_types.rb

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/permission_type.rb

@@ -1,7 +0,0 @@
-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_type.rb

@@ -1,14 +0,0 @@
-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/tests/permission_type_spec.rb

@@ -1,20 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe CanHasPermission::PermissionType do
-  it "should be valid with a name" do
-    role = CanHasPermission::PermissionType.new(:name => 'Bingo')
-    role.should be_valid
-  end
-  it "should not be valid without a name" do
-    role = CanHasPermission::PermissionType.new()
-    role.should_not be_valid
-  end
-  it "should not be valid when it has a name that already exists" do
-    name = 'the same'
-    role1 = CanHasPermission::PermissionType.create!(:name => 'the same')
-    role2 = CanHasPermission::PermissionType.new(:name => 'the same')
-    role1.should be_valid
-    role1.id.should_not be_nil
-    role2.should_not be_valid
-  end
-end

data/spec/tests/role_type_spec.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
-
-describe CanHasPermission::RoleType do
-  it "should be valid with a name" do
-    role = CanHasPermission::RoleType.new(:name => 'Bingo')
-    role.should be_valid
-  end
-  it "should not be valid without a name" do
-    role = CanHasPermission::RoleType.new()
-    role.should_not be_valid
-  end
-  it "should not be valid when it has a name that already exists" do
-    name = 'the same'
-    role1 = CanHasPermission::RoleType.create!(:name => 'the same')
-    role2 = CanHasPermission::RoleType.new(:name => 'the same')
-    role1.should be_valid
-    role1.id.should_not be_nil
-    role2.should_not be_valid
-  end
-  describe "creating a role_type with permissions" do
-    before(:each) do
-      @role = CanHasPermission::RoleType.create!(:name => 'joe')
-      @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
-end