permissable 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/permissable.rb

@@ -52,11 +52,14 @@ module Permissable
         
         write_inheritable_attribute :permissable_by_association, (options[:with] || false)
         class_inheritable_reader :permissable_by_association
-           
+        
+        write_inheritable_attribute :has_permissions_for, []
+        class_inheritable_accessor :has_permissions_for
+
         # The class that called permissable becomes a member.
         include Permissable::Member
-        has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }) unless permissable_by_association
         
+        # Yield the permissions block to add permissions.
         yield self
         
       end
@@ -64,29 +67,20 @@ module Permissable
       # +permission_for+ is called via the permissable block
       def permission_for(methods, *resources)
         
-        methods = [methods] unless methods.is_a?(Array)
-
-        resources.each do |resource|
-
-          klass = resource.to_s.classify          
-          klass.constantize.class_eval do
-            
-            write_inheritable_attribute :permissable_methods, methods
-            class_inheritable_reader   :permissable_methods
-            has_many(:permissions, :as => :resource, :conditions => { :resource_type => "#{self.to_s}" })
-            
-            include Permissable::Resource
-            
-          end
-          
-        end 
-               
-      end
-      
-    end
-    
+        methods = [methods].flatten
+        
+        # Add each resource to the member class' permissions list.
+        has_permissions_for.concat(resources).flatten.uniq
+        
+        resources.uniq.each do |resource|          
+          #Include the Resource module to each resource class.
+          resource.to_s.classify.constantize.class_eval{ include Permissable::Resource }
+          resource.to_s.classify.constantize.send :set_permissions!, methods
+        end
+        
+      end   
+         
+    end    
 end
 
-ActiveSupport.on_load :active_record do
-  ActiveRecord::Base.send :include, Permissable
-end
+ActiveRecord::Base.send :include, Permissable

data/lib/permissable/member.rb

@@ -2,24 +2,22 @@ module Permissable
   
   module Member
     
-    def self.included(base)
-      
+    def self.included(base)      
       base.send :include, InstanceMethods
-      
-      if base.permissable_by_association
-        base.send :include, AssociatedMethods
-        # Add a has many to our association so it can find permissions.
-        base.permissable_by_association.to_s.classify.constantize.class_eval do
-          has_many :permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }
-        end
-      else
-        base.send :include, MemberMethods
+      member_klass = (base.permissable_by_association) ? base.permissable_by_association.to_s.classify.constantize : base
+      member_klass.class_eval do 
+        has_many :permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }
       end
+      base.send :include, ((base.permissable_by_association) ? AssociatedMethods : MemberMethods)
     end
     
     # This module includes methods that should exist on ALL members.
     module InstanceMethods
       
+      # When a member is initialized, its definitions are eager-loaded to cut down on database queries.
+      # Once loaded all of the permission definitions are cached into the @permission_definitions variable.
+      attr_accessor :permission_definitions
+      
       # Can this member perform the requested action?
       def can?(method, resource)
         method = method.to_s       
@@ -27,40 +25,38 @@ module Permissable
       end
       
       # Set a permission
-      def can!(method, resource)
-        method    = method.to_s.downcase
-        klassname = permissable_by_association ? permissable_by_association.to_s.classify : self.class.to_s
-        
-        throw Permissable::ResourceNotPermissable unless resource.respond_to? :permissable_methods
-        throw Permissable::PermissionNotDefined unless resource.permissable_methods.include?(method)
-        
-        members.each do |m|
-          next if resource.permissions.for_member_and_resource(m,resource).exists?
-          new_permission = Permission.new()
-          new_permission.member   = m
-          new_permission.resource = resource
-          new_permission.permission_type = method
-          new_permission.save 
-        end
+      def can!(methods, resource)
+        methods = [methods].flatten.uniq
         
+        members.each do |member|
+          methods.each do |perm|
+            next if resource.permissions.for_member(member).with_permission_to(perm).exists?
+            new_permission = Permission.new({ :permission_type => method.to_s })
+            new_permission.member   = m
+            new_permission.resource = resource
+            new_permission.save 
+          end
+        end        
+      end
+      
+      def cannot?(methods, resource)
+        !can?(methods, resource)
+      end
+      
+      def cannot!(methods, resources)
+        methods  = [methods].flatten.uniq
+        existing = permissions.for_resource(resource).with_permission_to(methods).all.collect{ |perm| perm.id }
+        Permission.destroy(existing)
       end
       
       def permissions_for(resource)
-        if resource.is_a?(Class)
-          permissions_scope[resource.to_s]
-        else
-          permissions.for_resource(resource).all.collect{ |p| p.permission_type.to_sym }.uniq
-        end
+        permissions.for_resource(resource).all.collect{ |p| p.permission_type.to_sym }.uniq
       end
       
       def permissions_for?(resource)
         !permissions_for(resource).empty?
       end
       
-      def permissions_for!(resources, *perms)
-        
-      end
-      
       private
       
       def get_const(resource)

data/lib/permissable/permission.rb

@@ -4,11 +4,13 @@ class Permission < ActiveRecord::Base
   
   class << self
     def for_member(member)
-      where(:member_id => member.id, :member_type => member.class.to_s)
+      member = flatten(member)
+      where(:member_id => member[:ids], :member_type => member[:types])
     end
     
     def for_resource(resource)
-      where(:resource_id => resource.id, :resource_type => resource.class.to_s)
+      resource = flatten(resource)
+      where(:resource_id => resource[:ids], :resource_type => resource[:types])
     end
     
     def for_member_and_resource(member, resource)
@@ -16,8 +18,14 @@ class Permission < ActiveRecord::Base
     end
     
     def with_permission_to(perm)
-      where(:permission_type => perm.to_s)
+      perm = perm.is_a?(Array) ? perm.collect{ |p| p.to_s } : perm.to_s
+      where(:permission_type => perm)
     end
   end
   
+  def flatten(obj)
+    return { :ids => obj, :types => obj.class.to_s } unless obj.is_a?(Array)
+    { :ids => obj.collect{ |o| o.id }, :types => obj.collect{ |o| o.class.to_s } }
+  end
+    
 end

data/lib/permissable/resource.rb

@@ -2,10 +2,18 @@ module Permissable
   
   module Resource
     
-    private
+    def self.included(base)
+      base.class_eval{ has_many(:permissions, :as => :resource, :conditions => { :resource_type => "#{self.to_s}" }) }
+      base.extend(ClassMethods)
+    end
     
-    def self.set_permissions!
-      puts permissable_methods.inspect
+    module ClassMethods
+      private 
+      def set_permissions!(permission_list)
+        class_inheritable_accessor :permissable_methods
+        write_inheritable_attribute(:permissable_methods, []) if permissable_methods.nil?
+        permissable_methods.concat permission_list.uniq.flatten
+      end
     end
     
   end

data/permissable.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{permissable}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   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: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Brent Kirby