cantango 0.8.0 → 0.8.5.1

data/lib/cantango.rb

@@ -2,20 +2,17 @@ require 'cantango/rails/railtie' if defined?(Rails)
 require 'cantango/rails/engine' if defined?(Rails)
 require 'cancan'
 require 'cantango/cancan/rule'
-require 'sugar-high/class_ext'
 require 'sugar-high/array'
 require 'sugar-high/blank'
 require 'hashie'
-require 'cutter'
-require 'moneta'
+require 'sweetloader'
 
-# AutoLoader.root = ''
 AutoLoader.namespaces = {:CanTango => 'cantango'}
 
 module CanTango
-  autoload_modules :Ability, :Api, :Configuration, :Cache
+  autoload_modules :Ability, :Api, :Configuration, :Cache, :Permits
   autoload_modules :PermitEngine, :Rails, :Users
-  autoload_modules :PermissionEngine, :Rules, :Api, :Helpers
+  autoload_modules :PermissionEngine, :Rules, :Api, :Helpers, :Filters, :Engine
 
   class << self
     def configure &block
@@ -29,4 +26,5 @@ module CanTango
 end
 
 require 'cantango/api/aliases'
+require 'cantango/permits/macros'
 require 'cantango/users/macros'

data/lib/cantango/ability.rb

@@ -1,17 +1,14 @@
-# @stanislaw: needed?
 require 'cantango/permit_engine/util'
 
 module CanTango
   class Ability
-    autoload_modules :ClassMethods, :Scope, :Cache
+    autoload_modules :Scope, :Cache
     autoload_modules :MasqueradeHelpers, :PermitHelpers, :PermissionHelpers
-    autoload_modules :UserHelpers, :RoleHelpers
+    autoload_modules :UserHelpers, :RoleHelpers, :CacheHelpers
 
     include CanCan::Ability
-    include Cache
-    extend  ClassMethods
 
-    attr_reader :options, :subject, :session
+    attr_reader :options, :subject, :session, :candidate
 
     # Equivalent to a CanCan Ability#initialize call
     # which executes all the permission logic
@@ -22,31 +19,45 @@ module CanTango
 
       return if cached_rules?
 
-      # run permission evaluators
-      with(:permissions)  {|permission| permission.evaluate! user }
-      with(:permits)      {|permit| break if permit.execute == :break }
+      clear_rules!
+      permit_rules
+      execute_engines!
 
-      cache_rules!
+      cache_rules! if caching_on?
     end
 
     include CanTango::PermitEngine::Util
 
-    def with engine_type, &block
-      send(engine_type).each do |obj|
-        yield obj
-      end if send(:"#{engine_type}?")
+    def permit_rules
+    end
+
+    def clear_rules!
+      @rules = []
+    end
+
+    def execute_engines!
+      each_engine {|engine| engine.new(self).execute! if engine  }
+    end
+
+    def each_engine &block
+      engines.execution_order.each {|name| yield engines.registered[name] if engines.active? name }
+    end
+
+    def engines
+      CanTango.config.engines
     end
 
     def subject
-      return @candidate.active_user if masquerade_user?
-      return @candidate.active_account if masquerade_account?
-      @candidate
+      return candidate.active_user if masquerade_user?
+      return candidate.active_account if masquerade_account?
+      candidate
     end
 
     def config
       CanTango.config
     end
 
+    include CacheHelpers
     include MasqueradeHelpers
     include PermissionHelpers
     include PermitHelpers

data/lib/cantango/ability/cache.rb

@@ -1,92 +1,62 @@
 module CanTango
   class Ability
-    module Cache
-      autoload_modules :BaseCache, :SessionCache, :MonetaCache, :Kompiler
+    class Cache
+      autoload_modules :BaseCache, :SessionCache, :Reader, :Writer, :RulesCache, :Key
 
-      include CanTango::Ability::Cache::Kompiler
+      attr_reader :rules_cached, :ability
 
-      attr_reader :rules_cached
-
-      def rules
-        return cached_rules if cached_rules?
-        super
-      end
-
-      def cache_rules!
-        return if !caching_on?
-        invalidate_cache!
-        rules_compiled = compile_rules! rules
-        rules_cache.save cache_key, rules_compiled
-        session_check!
-        session[:cache_key] = cache_key
+      def initialize ability
+        @ability = ability
       end
 
-      def caching_on?
-        CanTango.config.cache.on?
+      def session
+        ability.session
       end
 
-      def cached_rules?
-        caching_on? && cache_key_same?
+      def cache_rules!
+        writer.save key, reader.prepared_rules
       end
 
       def cached_rules
-        rules_compiled = rules_cache.load(cache_key)
-        rules_raw = decompile_rules! rules_compiled
-        @rules ||= rules_raw
+        @rules ||= reader.prepared_rules
       end
 
-      def cache_key
-        @cache_key ||= begin
-          user_key_field = CanTango.config.user.unique_key_field || :email
-          raise "#{user.class} must have a method ##{user_key_field}. You can configure this with CanTango.config#user.unique_key_field" if !user.respond_to?(user_key_field)
-
-          user_key = user.send(user_key_field)
-          [user_key, subject_roles_hash].hash
-        end
+      def compiler
+        @compiler ||= Kompiler.new
       end
 
-      def subject_roles_hash
-        [subject.roles_list, subject.role_groups_list].hash
+      def reader
+        @reader ||= Reader.new(self)
       end
 
-      def invalidate_cache!
-        session_check!
-        rules_cache.invalidate! session[:cache_key]
+      def writer
+        @writer ||= Writer.new(self)
       end
 
-      def rules_cache
-        @rules_cache ||= rules_cache_instance
-      end
-
-      protected
-
-      def cache_key_same?
-        session_check!
-        session[:cache_key] && (cache_key == session[:cache_key])
+      def cached_rules?
+        key.same? session
       end
 
-      def rules_cache_instance
-        @rules_cache_instance ||= begin
-          options = rules_cache_options
-          options.merge!(:session => session) if session?
-          rules_cache_class.new :rules_cache, options
-        end
+      def key
+        @key ||= Key.new ability.user, ability.subject
       end
 
-      def rules_cache_options
-       CanTango.config.cache.store.options || {}
+      def rules_cache
+        @rules_cache ||= RulesCache.new(session).instance
       end
 
-      def rules_cache_class
-        CanTango.config.cache.store.default_class
+      def invalidate!
+        raise "no session" if !session
+        rules_cache.invalidate! session[:cache_key]
       end
 
-      def session?
-        session
+      def compile_on?
+        return false if !compile_adapter?
+        CanTango.config.cache_engine.compile?
       end
 
-      def session_check!
-        raise "No session available" if !session?
+      def compile_adapter?
+        CanTango.config.adapters.registered?(:compiler)
       end
     end
   end

data/lib/cantango/ability/cache/base_cache.rb

@@ -1,6 +1,6 @@
 module CanTango
   class Ability
-    module Cache
+    class Cache
       class BaseCache
         attr_reader :name, :options
 

data/lib/cantango/ability/cache/key.rb

@@ -0,0 +1,39 @@
+module CanTango
+  class Ability
+    class Cache
+      class Key
+        attr_reader :user, :subject
+
+        def initialize user, subject
+          @user = user
+          @subject = subject
+        end
+
+        def value
+          raise "#{user.class} must have a method ##{user_key_field}. You can configure this with CanTango.config#user.unique_key_field" if !user.respond_to?(user_key_field)
+          @value ||= [user_key, subject_roles_hash].hash
+        end
+
+        def same? session
+          raise "No session available" if !session
+          session[:cache_key] && (value == session[:cache_key].value)
+        end
+
+        protected
+
+        def user_key
+          user.send(user_key_field)
+        end
+
+        def user_key_field
+          CanTango.config.user.unique_key_field || :email
+        end
+
+        def subject_roles_hash
+          [subject.roles_list, subject.role_groups_list].hash
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/ability/cache/kompiler.rb

@@ -1,23 +1,39 @@
 require 'sourcify'
+
 module CanTango
   class Ability
-    module Cache
-      module Kompiler
+    class Cache
+      class Kompiler
+        class CacheMarshallError < StandardError; end
 
-        def compile_rules! rules_raw
+        def compile! rules_raw
+          return if !rules_raw
           rules_compiled = rules_raw.map do |rule|
-            rule.block = rule.block.to_source if rule.block.class == Proc
+            rule.block = rule.block.to_source if rule.block.class == Proc && sourcify?
             rule
           end
         end
 
-        def decompile_rules! rules_compiled
+        def decompile! rules_compiled
+          return if !rules_compiled
           rules_raw = rules_compiled.map do |rule|
-            rule.block = eval("#{rule.block}")
+            compiler_check! rule
+            rule.block = eval("#{rule.block}") if sourcify?
             rule
           end
         end
 
+        protected
+
+        def sourcify?
+          @sourcify ||= Proc.new {}.respond_to?(:to_source)
+        end
+
+        def compiler_check! rule
+          if rule.block && !CanTango.config.adapters.registered?(:compiler)
+            raise "You can NOT marshal dynamic rules (with Procs) unless you register the :compiler adapter"
+          end
+        end
       end
     end
   end

data/lib/cantango/ability/cache/moneta_cache.rb

@@ -3,7 +3,7 @@ require 'active_support/inflector'
 
 module CanTango
   class Ability
-    module Cache
+    class Cache
       class MonetaCache
         # one cache store is shared for all store instances (w different names)
         attr_reader :store

data/lib/cantango/ability/cache/reader.rb

@@ -0,0 +1,32 @@
+module CanTango
+  class Ability
+    class Cache
+      class Reader
+        attr_reader :cache
+
+        def initialize cache
+          @cache = cache
+        end
+
+        def prepared_rules
+          cache.compile_on? ? compiler.decompile!(loaded_rules) : loaded_rules
+        end
+
+        protected
+
+        def loaded_rules
+          rules_cache.load(cache.key)
+        end
+
+        def compiler
+          cache.compiler
+        end
+
+        def rules_cache
+          cache.rules_cache
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/ability/cache/rules_cache.rb

@@ -0,0 +1,31 @@
+module CanTango
+  class Ability
+    class Cache
+      class RulesCache
+        attr_reader :session
+
+        def instance
+          @instance ||= clazz.new :rules_cache, options
+        end
+
+        def initialize session = nil
+          @session = session
+        end
+
+        def options
+          @options ||= session ? cache_options.merge(:session => session) : cache_options
+        end
+
+        def cache_options
+          CanTango.config.cache_engine.store.options || {}
+        end
+
+        def clazz
+          CanTango.config.cache_engine.store.default_class
+        end
+      end
+    end
+  end
+end
+
+

data/lib/cantango/ability/cache/session_cache.rb

@@ -1,6 +1,6 @@
 module CanTango
   class Ability
-    module Cache
+    class Cache
       class SessionCache < BaseCache
         attr_accessor :session
 
@@ -30,7 +30,8 @@ module CanTango
         end
 
         def cache
-          CanTango::Cache::MonetaCache.instance
+          CanTango::Cache::HashCache.instance
+          # CanTango::Cache::MonetaCache.instance
         end
       end
     end

data/lib/cantango/ability/cache/writer.rb

@@ -0,0 +1,42 @@
+module CanTango
+  class Ability
+    class Cache
+      class Writer
+        attr_reader :cache
+
+        def initialize cache
+          @cache = cache
+        end
+
+        def save key, rules
+          cache.invalidate!
+          cache.rules_cache.save cache.key, prepared_rules
+          session[:cache_key] = cache.key if session
+        end
+
+        protected
+
+        def prepared_rules
+          cache.compile_on? ? compiler.compile!(rules) : rules
+        end
+
+        def rules
+          return cache.cached_rules if cache.cached_rules?
+          cache.ability.send :rules # bad!? FIXME
+        end
+
+        def compiler
+          cache.compiler
+        end
+
+        def session
+          cache.session
+        end
+
+        def rules_cache
+          cache.rules_cache
+        end
+      end
+    end
+  end
+end