permissable 0.2.0 → 0.2.1

data/README.rdoc

@@ -54,14 +54,23 @@ member model that will be called prior to checking permissions from the database
 	  end
 	end
 
+== Chaining Permissions
+
+If you want your permissions to have a heirarchy, use the :chain option. For example, say you have three permission types: read, write, and moderate. In this instance, moderators should also be able to read and write a resource, and members who can write should also be able to read the resource. To do this, add this chain when calling has_permissions_for:
+
+	class User < ActiveRecord::Base
+	  	has_permissions_for [:resource], 
+	                    :to => [:read, :write, :moderate],
+	                    :chain => { :moderate => [:read, :write], :write => [:read] }
+	end
+	
+Now calling can?(:read, @resource) will evaluate to true when permissions exist for reading or writing, and can?(:read, @resource) will evaluate to true when permissions exist at least to write.
+
 == Planned Updates
 
 In the near future there are plans to add the ability to "eager_load" permissions on a user the first time it is created. When using this configuration 
 option, ALL permissions relating to that user are looked up in a single database query, and then cached to the user instance. By default I think this may be the proper way to handle it anyway.
 
-We are also planning to implement permission "chains". Basically this will define a series of "levels" to your permission. For instance a user
-who can "write" a model, would also be able to "read" a model. You would be able to tell Permissable which methods chain from each other and
-the order they should rely on.  Think about how a statemachine transitions from one state to another in a way....
 
 == Note on Patches/Pull Requests
  

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/permissable/member.rb

@@ -30,6 +30,11 @@ module Permissable
       # TODO: There has to be a friendlier way to mass assign permissions to roles rather than
       # looping each one for existence and then saving separately.
       def can!(methods, resources)
+        
+        # This method should return all of the new permissions that were created, so we build a 
+        # response array to return
+        response = []
+        
         [resources].flatten.each do |resource|
           
           # Kind of unecessary but since some methods allow you to specify a Classname directly, this just
@@ -48,10 +53,13 @@ module Permissable
               perm = Permission.new(:member_id => member_id, :member_type => identifier[:member_type], :permission_type => method.to_s.downcase)
               perm.resource = resource
               perm.save
+              response << perm
             end
           end
         end
         
+        (response.size == 1) ? response.first : response
+        
       end
       
       # This sets the member information for our permission lookup based on the current resource scope.

data/lib/permissable.rb

@@ -71,7 +71,7 @@ module Permissable
             
             # Our association also creates a has_many association on our permissions table.
             assoc.class_eval do              
-              has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }) unless respond_to? :permissions
+              has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }), :dependent => :destroy unless respond_to? :permissions
               include Permissable::Member
               class_inheritable_accessor :permission_types
               write_inheritable_attribute(:permissable_associations, {})
@@ -85,7 +85,7 @@ module Permissable
 
           # Setup a has_many association of permissions on our resource.
           resource.constantize.class_eval do             
-            has_many(:permissions, :as => :resource, :conditions => { :resource_type => "#{self.to_s}" }) unless respond_to? :permissions
+            has_many(:permissions, :as => :resource, :conditions => { :resource_type => "#{self.to_s}" }), :dependent => :destroy unless respond_to? :permissions
           end
           
           resource.constantize.instance_eval{ include Permissable::Resource }
@@ -101,7 +101,7 @@ module Permissable
         self.send :permission_types=, options[:to]
         
         # Members create a has_many association on permissions as a member.
-        has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }) unless respond_to? :permissions
+        has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }), :dependent => :destroy unless respond_to? :permissions
         
       end 
       

data/permissable.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{permissable}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brent Kirby"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: permissable
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Brent Kirby