cantango 0.8.9.5 → 0.9.3.2

data/lib/cantango/ability_executor.rb

@@ -0,0 +1,41 @@
+module CanTango
+  class AbilityExecutor < CanTango::Ability
+    attr_reader :rules
+
+    def initialize candidate, options = {}
+      raise "Candidate must be something!" if !candidate
+      @candidate, @options = [candidate, options]
+      @rules = cached_rules + non_cached_rules
+    end
+
+    def cached_rules
+      cache_mode? ? cached_ability.send(:rules) : []
+    end
+
+    def non_cached_rules
+      no_cache_mode? ? non_cached_ability.send(:rules) : []
+    end
+
+    def cached_ability
+      CanTango::CachedAbility.new candidate, options
+    end
+
+    def non_cached_ability
+      CanTango::Ability.new candidate, options
+    end
+
+    protected
+
+    def no_cache_mode?
+      modes.include?(:no_cache)
+    end
+
+    def cache_mode?
+      modes.include?(:cache)
+    end
+
+    def modes
+      CanTango.config.ability.modes
+    end
+  end
+end

data/lib/cantango/api/user/ability.rb

@@ -17,24 +17,20 @@ module CanTango
         def get_ability_user user_type
           user_meth = :"current_#{user_type}"
           return AbilityUser.guest if !respond_to?(user_meth)
+          AbilityUser.resolve_user(send user_meth)
+       end
 
-          user = send user_meth
+        module AbilityUser
           # test if current_xxx actually returns an account and not a user instance!
           # if so call the #user method on the account
-          user = AbilityUser.resolve_user(user)
-          # return guest user if user is nil
-          user ? user : AbilityUser.guest
-        end
-
-        module AbilityUser
           def self.resolve_user obj
-            return obj if AbilityUser.is_a_user?(obj)
-            return obj.send(:user) if obj.respond_to? :user
-            raise "no user object could be resolved via #{obj}. Please define a #user method for #{obj.class}"
+            return obj if is_user?(obj)
+            return resolve_user(obj.send(:user)) if obj.respond_to? :user
+            guest
           end
 
-          def self.is_a_user? user
-            ::CanTango.config.users.registered.include?(user.class.to_s.underscore.to_sym)
+          def self.is_user? user
+            ::CanTango.config.users.registered_class? user.class
           end
 
           def self.guest

data/lib/cantango/api/user/session.rb

@@ -22,7 +22,8 @@ module CanTango
         def any_user *types
           types = types.flatten.select_labels.map(&:to_sym)
           c_user = ::CanTango.config.users.registered.each do |user|
-          send(:"current_#{user}") if respond_to?(:"current_#{user}") && (types.empty? || types.include?(user))
+            meth = :"current_#{user}"
+            send(meth) if respond_to?(meth) && (types.empty? || types.include?(user))
           end.compact.first
           c_user || guest_user
         end

data/lib/cantango/api/user_account.rb

@@ -1,11 +1,11 @@
 module CanTango
   module Api
     module UserAccount
-      autoload_modules :Ability, :Can, :Scope
+      autoload_modules :Ability, :Can, :Scope, :Session
 
       module All
         def self.included base
-          [:Ability, :Can, :Scope].each do |api|
+          [:Ability, :Can, :Scope, :Session].each do |api|
             base.send :include, clazz(api)
           end
         end

data/lib/cantango/api/user_account/ability.rb

@@ -5,30 +5,35 @@ module CanTango
         def user_account_ability user_account, options = {}
           @current_ability ||= create_ability(user_account, ability_options.merge(options))
         end
+        alias_method :account_ability, :user_account_ability
 
         def current_account_ability user_type = :user
-          account_meth = :"current_#{user_type}_account"
-          return guest_user_account if !respond_to?(account_meth)
-
-          user_account = send(account_meth)
-          return guest_user_account if !user_account
-
-          user_account_ability user_account
+         user_account_ability get_ability_user_account
         end
 
         protected
 
         include CanTango::Api::Common
 
-        def get_ability_user_acount user_type
-          user_account_meth = :"current_#{user_type}_account"
-          return AbilityAccount.guest if !respond_to?(user_account_meth)
-
-          user_account = send user_account_meth
-          user_account ? user_account : AbilityAccount.guest
-        end
+        def get_ability_user_account user_type = :user
+          account_meth = :"current_#{user_type}_account"
+          return AbilityAccount.guest if !respond_to?(account_meth)
+          AbilityAccount.resolve_account(send account_meth)
+       end
 
         module AbilityAccount
+          # test if current_xxx actually returns an account and not a user instance!
+          # if so call the #account method on the user
+          def self.resolve_account obj
+            return obj if AbilityAccount.is_account?(obj)
+            return resolve_account(obj.send(:account)) if obj.respond_to?(:account)
+            guest
+          end
+
+          def self.is_account? account
+            ::CanTango.config.user_accounts.registered_class? account.class
+          end
+
           def self.guest
             account = CanTango.config.guest.account
 

data/lib/cantango/api/user_account/can.rb

@@ -9,6 +9,14 @@ module CanTango
         # end
         def self.included(base)
           ::CanTango.config.user_accounts.registered.each do |account|
+
+            # by default alias call to current_xxx_account to current_xxx (devise user method) unless already defined!
+            unless base.methods.include? :"current_#{account}_account"
+              define_method :"current_#{account}_account" do
+                send :"current_#{account}"
+              end
+            end
+
             base.class_eval %{
               def #{account}_account_can? *args
                 current_account_ability(:#{account}).can?(*args)

data/lib/cantango/api/user_account/session.rb

@@ -0,0 +1,33 @@
+module CanTango
+  module Api
+    module UserAccount
+      module Session
+        def self.included(base)
+          ::CanTango.config.user_accounts.registered.each do |type|
+            base.class_eval %{
+              def session_#{type}_account
+                current_#{type}_account if respond_to? :current_#{type}_account
+                guest_account
+              end
+            }
+          end
+        end
+
+        # give me any logged in user or the guest user
+        def any_account *types
+          types = types.flatten.select_labels.map(&:to_sym)
+          c_account = ::CanTango.config.user_accounts.registered.each do |type|
+            meth = :"current_#{type}_account"
+            send(meth) if respond_to?(meth) && (types.empty? || types.include?(user))
+          end.compact.first
+          c_account || guest_account
+        end
+
+        def guest_account
+          CanTango.config.guest.account
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/cached_ability.rb

@@ -0,0 +1,26 @@
+module CanTango
+  class CachedAbility < Ability
+    # Equivalent to a CanCan Ability#initialize call
+    # which executes all the permission logic
+    def initialize candidate, options = {}
+      raise "Candidate must be something!" if !candidate
+      @candidate, @options = candidate, options
+
+      return if cached_rules?
+
+      clear_rules!
+      permit_rules
+
+      execute_engines! if engines_on?
+      cache_rules!
+    end
+
+    def cached?
+      true
+    end
+
+    def permit_rules
+    end
+  end
+end
+

data/lib/cantango/configuration.rb

@@ -6,15 +6,15 @@ module CanTango
     autoload_modules :Categories
     autoload_modules :Models, :Engines, :Ability
     autoload_modules :User, :Guest, :UserAccount
-    autoload_modules :Roles, :RoleGroups, :Registry, :RoleRegistry, :HashRegistry, :PermitRegistry, :Factory
-    autoload_modules :SpecialPermits, :Autoload, :Adapters, :Permits, :Debug
+    autoload_modules :Roles, :RoleGroups, :Registry, :RoleRegistry, :HashRegistry, :PermitRegistry, :CandidateRegistry, :Factory
+    autoload_modules :SpecialPermits, :Autoload, :Adapters, :Permits, :Debug, :Modes
     autoload_modules :Users, :UserAccounts
 
     include Singleton
 
     def ability
       @ability ||= conf::Ability.instance
-      @ability.default_class ||= CanTango::Ability
+      @ability.default_class ||= CanTango::AbilityExecutor
       @ability
     end
 

data/lib/cantango/configuration/ability.rb

@@ -5,6 +5,7 @@ module CanTango
       include ClassExt
 
       include CanTango::Configuration::Factory
+      include CanTango::Configuration::Modes
     end
   end
 end

data/lib/cantango/configuration/candidate_registry.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+require 'sugar-high/kind_of'
+
+module CanTango
+  class Configuration
+    class CandidateRegistry
+      def register name, clazz
+        raise "first arg must be a label" if !name.kind_of_label?
+        raise "second arg must be a Class" if !clazz.kind_of? Class
+        name_registry.register name.to_sym
+        class_registry.register clazz
+      end
+
+      def registered
+        name_registry.registered
+      end
+
+      def registered_classes
+        class_registry.registered
+      end
+
+      def registered? name
+        name_registry.registered? name
+      end
+
+      def registered_class? name
+        class_registry.registered? name
+      end
+
+      def name_registry
+        NameRegistry.instance
+      end
+
+      def class_registry
+        ClassRegistry.instance
+      end
+
+      class NameRegistry < Registry
+        include Singleton
+      end
+
+      class ClassRegistry < Registry
+        include Singleton
+
+        def types
+          [Class]
+        end
+      end
+    end
+  end
+end

data/lib/cantango/configuration/categories.rb

@@ -1,7 +1,7 @@
 module CanTango
   class Configuration
     class Categories < HashRegistry
-     
+
       include Singleton
 
       def [] label
@@ -9,7 +9,7 @@ module CanTango
         raise "Category '#{label}' either not exists or invalid!" if !models.kind_of?(Array)
         models
       end
-      
+
       def category label, &block
         cat = Category.new self[label]
         yield cat if block

data/lib/cantango/configuration/engines.rb

@@ -3,7 +3,7 @@ require 'singleton'
 module CanTango
   class Configuration
     class Engines
-      autoload_modules :Permission, :Permit, :Cache, :Store, :Engine
+      autoload_modules :Permission, :Permit, :UserAc, :Cache, :Store, :Engine
 
       include Singleton
       include Enumerable
@@ -29,7 +29,7 @@ module CanTango
       end
 
       def default_register
-        {:permit => CanTango::PermitEngine, :permission => CanTango::PermissionEngine }
+        {:permit => CanTango::PermitEngine, :permission => CanTango::PermissionEngine, :user_ac => CanTango::UserAcEngine }
       end
 
       # defines the order of execution of engine in ability
@@ -60,7 +60,7 @@ module CanTango
       end
 
       def self.default_available
-        [:cache, :permission , :permit]
+        [:cache, :permission , :permit, :user_ac]
       end
 
       def default_available
@@ -79,6 +79,10 @@ module CanTango
         available.each {|engine| send(engine).set state }
       end
 
+      def any? state
+        available.any? {|engine| send(engine).send(:"#{state}?") if respond_to?(engine) }
+      end
+
       def clear!
         each {|engine| engine.reset! }
         @registered = nil

data/lib/cantango/configuration/engines/permission.rb

@@ -5,6 +5,11 @@ module CanTango
     class Engines
       class Permission < Engine
         include Singleton
+        include CanTango::Configuration::Modes
+
+        def modes
+          @modes ||= [:cache]
+        end
 
         def store &block
           @store ||= ns::Store.new

data/lib/cantango/configuration/engines/permit.rb

@@ -5,6 +5,7 @@ module CanTango
     class Engines
       class Permit < Engine
         include Singleton
+        include CanTango::Configuration::Modes
 
         def on?
           @state ||= :on

data/lib/cantango/configuration/engines/user_ac.rb

@@ -0,0 +1,19 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engines
+      class UserAc < Engine
+        include Singleton
+        include CanTango::Configuration::Modes
+
+        def modes
+          @modes ||= [:no_cache]
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/cantango/configuration/guest.rb

@@ -19,7 +19,7 @@ module CanTango
         return (@account || guest_account) if !account && !block
         @account = account || yield
       end
-
+      alias_method :user_account, :account
       alias_method :account=, :account
 
       def default_user?

data/lib/cantango/configuration/modes.rb

@@ -0,0 +1,21 @@
+module CanTango
+  class Configuration
+    module Modes
+      def modes
+        @modes ||= [:cache, :no_cache]
+      end
+
+      def mode= mode_name
+        mode_name = mode_name.to_sym
+        raise ArgumentException, "Not a valid mode name" if !valid_mode_names.include? mode_name
+        @modes = (mode_name == :both) ? [:cache, :no_cache] : [mode_name]
+      end
+
+      private
+
+      def valid_mode_names
+        [:cache, :no_cache, :both]
+      end
+    end
+  end
+end