permissable 0.2.1 → 0.2.2

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/permissable.rb

@@ -15,6 +15,7 @@
 require 'permissable/member'
 require 'permissable/permission'
 require 'permissable/resource'
+require 'permissable/permissions_cache'
 
 module Permissable
     
@@ -22,7 +23,13 @@ module Permissable
             
       def included(base)
         base.extend ClassMethods
-      end     
+      end
+      
+      # Creates a hash from a resource to be used in a where context.
+      def flatten_resource(obj)
+        return { :resource_id => obj.id, :resource_type => obj.base_class.to_s } unless obj.is_a?(Array)
+        { :resource_id => obj.collect{ |o| o.id }, :resource_type => obj.collect{ |o| o.base_class.to_s } }
+      end
       
     end
     
@@ -71,21 +78,20 @@ 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}" }), :dependent => :destroy unless respond_to? :permissions
+              has_many(:permissions, :as => :member, :dependent => :destroy) unless respond_to? :permissions
               include Permissable::Member
-              class_inheritable_accessor :permission_types
-              write_inheritable_attribute(:permissable_associations, {})
+              class_inheritable_accessor :permissable_types
+              self.send :permissable_types=, options[:to]
               write_inheritable_attribute(:permissable_options, {}) if permissable_options.nil?
               permissable_options[:allow_permission_with_method] = options[:allow_with] if options.has_key?(:allow_with)        
-              permissable_options[:permission_chain] = options[:chain] if options.has_key?(:chain)
-              self.send :permission_types=, options[:to]
+              permissable_options[:permission_chain] = options[:chain] if options.has_key?(:chain)              
             end
                                     
           end
 
           # 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}" }), :dependent => :destroy unless respond_to? :permissions
+            has_many(:permissions, :as => :resource, :dependent => :destroy) unless respond_to? :permissions
           end
           
           resource.constantize.instance_eval{ include Permissable::Resource }
@@ -97,11 +103,13 @@ module Permissable
         
         # This class becomes a member to resources.
         include Permissable::Member
-        class_inheritable_accessor :permission_types
-        self.send :permission_types=, options[:to]
+        class_inheritable_accessor :permissable_types
+        class_inheritable_accessor :permissable_resources
+        self.send :permissable_types=, options[:to]
+        self.send :permissable_resources=, resources
         
         # Members create a has_many association on permissions as a member.
-        has_many(:permissions, :as => :member, :conditions => { :member_type => "#{self.to_s}" }), :dependent => :destroy unless respond_to? :permissions
+        has_many(:permissions, :as => :member, :dependent => :destroy) unless respond_to? :permissions
         
       end 
       

data/lib/permissable/member.rb

@@ -5,22 +5,28 @@ module Permissable
     def self.included(base)      
       base.send :include, InstanceMethods
       base.send :attr_protected, :member_identifier
-      base.send :attr_protected, :permissable_lookups
+      base.send :attr_protected, :permissions_cache
+      base.send :attr_protected, :association_scopes
     end
      
     # This module includes methods that should exist on ALL members.
     module InstanceMethods
       
       # The can? method returns a boolen value specifying whether or not this member can perform the specific method on resource
-      def can?(methods, resource)
+      def can?(methods, resource, chain = true)
         unless allow_permission_with_method.nil?
           if self.respond_to? "#{allow_permission_with_method}"
             return true if (send "#{allow_permission_with_method}")
           end
         end
-        methods = [methods].flatten.collect{ |m| m.to_sym }
-        methods = find_methods_from_chain(methods)
-        permissions_for(resource, methods).exists?
+        
+        if chain
+          methods = [methods].flatten.collect{ |m| m.to_sym }
+          methods = find_methods_from_chain(methods)
+        end
+        
+        permissions_for?(resource, methods)
+        
       end
       
       # Alias to can? to get the inverse.
@@ -33,7 +39,7 @@ module Permissable
         
         # This method should return all of the new permissions that were created, so we build a 
         # response array to return
-        response = []
+        result_response = []
         
         [resources].flatten.each do |resource|
           
@@ -46,19 +52,19 @@ module Permissable
           
           [methods].flatten.each do |method|
             # Permission already exists, continue.
-            next if can?(method, resource)
+            next if can?(method, resource, false)
             
             # Create a new permission for each member (once if its self, multiple times if its associated)
             [identifier[:member_id]].flatten.each do |member_id|
               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
+              result_response << perm
             end
           end
         end
         
-        (response.size == 1) ? response.first : response
+        (result_response.size == 1) ? result_response.first : result_response
         
       end
       
@@ -72,20 +78,30 @@ module Permissable
         return @member_identifier[scope] unless @member_identifier[scope].nil?
         return { :member_id => self.id, :member_type => self.class.to_s } unless permissable_associations.has_key?(scope)
         
+        @association_scopes ||= {}
         assoc_key = permissable_associations[scope]
-        assoc     = send "#{assoc_key}".to_sym
+        @association_scopes[assoc_key] ||= send("#{assoc_key}".to_sym)
+        assoc = @association_scopes[assoc_key]
         
         @member_identifier[scope] = { :member_id => (assoc.is_a?(Array) ? assoc.collect{ |a| a.id } : assoc.id ), :member_type => assoc_key.to_s.classify }
         
       end
           
       # Provide an instance method to our associations
-      def permissable_associations; self.class.permissable_associations; end
+      def permissable_associations; self.class.permissable_associations || {}; end
       # Find our permission override if available
       def allow_permission_with_method; self.class.permissable_options[:allow_permission_with_method]; end
       # See if there is a permissions chain
       def permission_chain; self.class.permissable_options[:permission_chain] || {}; end
       
+      def permissions_for(resource)
+        fetch_permissions_for(resource).all.collect{ |perm| perm.permission_type.to_sym }
+      end
+      
+      def lookup_permissions!
+        @permissions_cache = PermissionsCache.new(Permission.where(:resource_type => self.class.permissable_resources.collect{ |r| r.to_s.classify }).all)
+      end
+      
       private 
       
       def find_methods_from_chain(methods)
@@ -106,12 +122,28 @@ module Permissable
       end
       
       # Looks up permissions for a particular resource.
-      def permissions_for(resource, methods = nil)
+      def fetch_permissions_for(resource, methods = nil)
         scope  = fetch_scope(resource)
-        return self.permissions.with_permission_to(methods) unless permissable_associations.has_key?(scope)
-        relation = Permission.where(member_identifier(scope)).for_resource(resource)
+        
+        lookup_with =  is_cached? ? @permissions_cache : Permission
+        relation = lookup_with.for_member(member_identifier(scope)).for_resource(resource)
         relation = relation.with_permission_to(methods) unless methods.nil?
-        relation
+        return relation
+        
+      end
+      
+      def fetch_scope(resource)
+        return resource if resource.is_a?(String)
+        (resource.is_a?(Class)) ? resource.to_s : resource.base_class.to_s.classify
+      end
+      
+      # Look to see if we have a permissions cache.
+      def is_cached?
+        !@permissions_cache.nil?
+      end
+      
+      def permissions_for?(resource, methods = nil)
+        fetch_permissions_for(resource, methods).exists?
       end
       
       # Returns the member responsible for this resource. This can either be an instance of self, or an instance or 
@@ -121,11 +153,6 @@ module Permissable
         (permissable_associations.has_key?(scope)) ? send("#{permissable_associations[scope]}".to_sym) : self
       end
       
-      def fetch_scope(resource)
-        return resource if resource.is_a?(String)
-        (resource.is_a?(Class)) ? resource.to_s : resource.class.to_s.classify
-      end
-      
     end
     
   end

data/lib/permissable/permission.rb

@@ -5,17 +5,16 @@ class Permission < ActiveRecord::Base
   class << self
     
     def for_resource(resource)
-      resource = flatten(resource)
+      resource = Permissable.flatten_resource(resource)
       where(resource)
     end
     
-    def with_permission_to(methods)
-      where(:permission_type => [methods].flatten.uniq.collect{ |m| m.to_s.downcase })
+    def for_member(member)
+      where(member)
     end
     
-    def flatten(obj)
-      return { :resource_id => obj, :resource_type => obj.class.to_s } unless obj.is_a?(Array)
-      { :resource_id => obj.collect{ |o| o.id }, :resource_type => obj.collect{ |o| o.class.to_s } }
+    def with_permission_to(methods)
+      where(:permission_type => [methods].flatten.uniq.collect{ |m| m.to_s.downcase })
     end
     
   end

data/lib/permissable/permissions_cache.rb

@@ -0,0 +1,68 @@
+module Permissable
+  
+  class PermissionsCache
+    
+    attr_accessor :_permissions
+    attr_accessor :_query_results
+    
+    def initialize(permission_list)
+      @_permissions   = permission_list
+      @_query_results = nil
+    end
+    
+    def for_member(member)
+      arr = create_result_array
+      @_query_results = arr.find_all do |perm|  
+        (member.key?(:member_type) ? true : perm.member_type == member[:member_type]) && [member[:member_id]].flatten.uniq.include?(perm.member_id)
+      end
+      
+      return self
+      
+    end
+    
+    def for_resource(resource)
+      arr = create_result_array
+      resource = Permissable.flatten_resource(resource)
+      @_query_results = arr.find_all do |perm|
+        [resource[:resource_id]].flatten.include?(perm.resource_id) && [resource[:resource_type]].flatten.include?(perm.resource_type)
+      end
+      
+      return self
+      
+    end
+    
+    def with_permission_to(methods)
+      arr = create_result_array      
+      @_query_results = arr.find_all do |perm|
+        [methods].flatten.collect{ |m| m.to_s }.include?(perm.permission_type)
+      end
+      
+      return self
+      
+    end
+    
+    def all
+      results = @_query_results || []
+      @_query_results = nil
+      results
+    end
+    
+    def exists?
+      results = @_query_results || []
+      @_query_results = nil
+      !results.empty?
+    end
+    
+    private
+    
+    def create_result_array
+      (@_query_results.nil?) ? permissions : @_query_results
+    end
+    
+    def permissions
+      @_permissions
+    end
+    
+  end
+  
+end

data/permissable.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{permissable}
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brent Kirby"]
-  s.date = %q{2010-09-04}
+  s.date = %q{2010-09-05}
   s.description = %q{Permissable lets you set a number of 'permissions' to your database models. By assigning 'members' to 'resources' (models) you can specify various permission states.}
   s.email = %q{brent@kurbmedia.com}
   s.extra_rdoc_files = [
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
      "lib/permissable.rb",
      "lib/permissable/member.rb",
      "lib/permissable/permission.rb",
+     "lib/permissable/permissions_cache.rb",
      "lib/permissable/resource.rb",
      "permissable.gemspec",
      "test/helper.rb",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: permissable
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Brent Kirby
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-04 00:00:00 -04:00
+date: 2010-09-05 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,6 +52,7 @@ files:
 - lib/permissable.rb
 - lib/permissable/member.rb
 - lib/permissable/permission.rb
+- lib/permissable/permissions_cache.rb
 - lib/permissable/resource.rb
 - permissable.gemspec
 - test/helper.rb