cantango 0.8.0 → 0.8.5.1

data/lib/cantango/ability/cache_helpers.rb

@@ -0,0 +1,28 @@
+module CanTango
+  class Ability
+    module CacheHelpers
+
+      def cached_rules?
+        caching_on? && cache.key.same?(session)
+      end
+
+      def cache_rules!
+        cache.cache_rules!
+      end
+
+      def cached_rules
+        cache.cached_rules
+      end
+
+      def cache
+        @cache ||= Cache.new self
+      end
+
+      protected
+
+      def caching_on?
+        CanTango.config.cache_engine.on?
+      end
+    end
+  end
+end

data/lib/cantango/ability/masquerade_helpers.rb

@@ -1,14 +1,19 @@
 module CanTango
   class Ability
     module MasqueradeHelpers
+
       def masquerade_user?
         return false if masquerading_off?
-        @candidate.respond_to?(:active_user) && @candidate.masquerading?
+        candidate.respond_to?(:active_user) && masquerading?
+      end
+
+      def masquerading?
+        candidate.respond_to?(:masquerading?) && candidate.masquerading?
       end
 
       def masquerade_account?
         return false if masquerading_off?
-        @candidate.respond_to?(:active_account)
+        candidate.respond_to?(:active_account)
       end
 
       def masquerading_off?

data/lib/cantango/ability/permission_helpers.rb

@@ -1,16 +1,8 @@
 module CanTango
   class Ability
     module PermissionHelpers
-      def permissions
-        permission_factory.build!
-      end
-
       protected
 
-      def permission_factory
-        @permission_factory ||= CanTango::PermissionEngine::Factory.new self
-      end
-
       def permissions?
         config.permissions.on?
       end

data/lib/cantango/ability/permit_helpers.rb

@@ -1,23 +1,6 @@
 module CanTango
   class Ability
     module PermitHelpers
-      # by default, only execute permits for which the user
-      # has a role or a role group
-      # also execute any permit marked as special
-      def permits
-        permit_factory.build!
-      end
-
-      def permit_class_names
-        @permit_class_names ||= permits.map{|p| p.class.to_s}
-      end
-
-      protected
-
-      def permit_factory
-        @permit_factory ||= CanTango::PermitEngine::Factory.new self
-      end
-
       def permits?
         config.permits.on?
       end

data/lib/cantango/ability/role_helpers.rb

@@ -5,7 +5,6 @@ module CanTango
       include CanTango::Helpers::RoleMethods
 
       # return list roles the user has
-      # TODO: should also fetch roles of all role_groups! (or is this responsibility of roles_list?)
       def roles
         raise "#{subject.inspect} should have a #{roles_list_meth} method" if !subject.respond_to?(roles_list_meth)
         subj_roles = subject.send(roles_list_meth)
@@ -14,7 +13,6 @@ module CanTango
       end
 
       # return list of symbols for role groups the user belongs to
-      # TODO: use roles filter here? or better in #valid? of selector ?
       def role_groups
         raise "#{subject.inspect} should have a #{role_groups_list_meth} method" if !subject.respond_to?(role_groups_list_meth)
         subj_role_groups = subject.send(role_groups_list_meth)

data/lib/cantango/ability/user_helpers.rb

@@ -10,6 +10,7 @@ module CanTango
         return subject.active_account if subject.respond_to? :active_account
         subject
       end
+      alias_method :account, :user_account
 
       def user_key_field
         key_field = config.user.unique_key_field

data/lib/cantango/adapter/compiler.rb

@@ -0,0 +1,9 @@
+module CanTango
+  class Ability
+    class Cache
+      autoload_modules :Kompiler
+    end
+  end
+end
+
+CanTango.config.adapters.register :compiler

data/lib/cantango/adapter/moneta.rb

@@ -0,0 +1,23 @@
+require 'moneta'
+
+module CanTango
+  module Cache
+    autoload_modules :MonetaCache
+  end
+end
+
+module CanTango
+  class Ability
+    class Cache
+      autoload_modules :MonetaCache
+    end
+  end
+end
+
+module CanTango
+  class PermissionEngine < Engine
+    autoload_modules :MonetaStore
+  end
+end
+
+CanTango.config.adapters.register :moneta

data/lib/cantango/api.rb

@@ -1,5 +1,5 @@
 module CanTango
   module Api
-    autoload_modules :User, :UserAccount, :Options, :Common
+    autoload_modules :User, :UserAccount, :Options, :Common, :Attributes
   end
 end

data/lib/cantango/api/aliases.rb

@@ -1,8 +1,4 @@
-$:.unshift File.dirname(__FILE__)
-require 'aliases/permit'
-require 'aliases/role_permit'
-require 'aliases/role_group_permit'
-require 'aliases/license'
-require 'aliases/user_permit'
-require 'aliases/account_permit'
-
+['', :role, :role_group,  :user, :account].each do |type|
+  eval "CanTango::#{type.to_s.camelize}Permit = CanTango::Permits::#{type.to_s.camelize}Permit"
+end
+CanTango::License = CanTango::Permits::License

data/lib/cantango/api/attributes.rb

@@ -0,0 +1,17 @@
+module CanTango
+  module Api
+    module Attributes
+      [:read, :edit].each do |action|
+        define_method :"#{action}_attribute" do |name|
+          :"#{action}_attr_\#{name}"
+        end
+
+        define_method :"#{action}_attributes" do |*names|
+          names.select_symbols.map { |name| send("#{action}_attribute", name) }
+        end
+      end
+    end
+  end
+end
+
+

data/lib/cantango/api/common.rb

@@ -1,9 +1,15 @@
 module CanTango
   module Api
     module Common
+      include CanTango::Api::Attributes
+
       def create_ability candidate, opts = {}
         CanTango.config.ability.factory_build candidate, opts
       end
+
+      def category label
+        config.models.by_category label
+      end
     end
   end
 end

data/lib/cantango/api/options.rb

@@ -4,13 +4,17 @@ module CanTango
 
       def ability_options
         opts = {}
-        opts.merge!(:session => session) if respond_to? :session
-        opts.merge!(:request => request) if respond_to? :request
-        opts.merge!(:params => params) if respond_to? :params
-        opts.merge!(:controller => controller) if respond_to? :controller
-        # puts "CanTango::Ability options:" << opts.keys.inspect
+        options_list.each do |option|
+          opts.merge!(option => send(option)) if respond_to? option
+        end
         opts
       end
+
+      private
+
+      def options_list
+        [:session, :request, :params, :controller, :domain]
+      end
     end
   end
 end

data/lib/cantango/cache.rb

@@ -1,6 +1,6 @@
 module CanTango
   module Cache
-    autoload_modules :MonetaCache
+    autoload_modules :HashCache
   end
 end
 

data/lib/cantango/cache/hash_cache.rb

@@ -0,0 +1,34 @@
+module CanTango
+  module Cache
+    class HashCache
+      include Singleton
+
+      attr_reader :options
+
+      def configure_with options = {}
+        @options ||= options
+      end
+
+      def load! key
+        cache[key]
+      end
+
+      def save! key, rules
+        cache[key] = rules
+      end
+
+      def delete key
+        cache[key].delete if cache[key]
+      end
+
+      def cache
+        @cache ||= {}
+      end
+
+      def type
+        :memory
+      end
+    end
+  end
+end
+

data/lib/cantango/configuration.rb

@@ -6,8 +6,8 @@ module CanTango
     autoload_modules :Categories
     autoload_modules :Models, :Engines, :Ability
     autoload_modules :User, :Guest, :UserAccount
-    autoload_modules :Roles, :RoleGroups, :Registry, :RoleRegistry, :HashRegistry, :Factory
-    autoload_modules :SpecialPermits, :Autoload
+    autoload_modules :Roles, :RoleGroups, :Registry, :RoleRegistry, :HashRegistry, :PermitRegistry, :Factory
+    autoload_modules :SpecialPermits, :Autoload, :Adapters, :Permits
     autoload_modules :Users, :UserAccounts
 
     include Singleton
@@ -21,7 +21,7 @@ module CanTango
     def self.components
       [
         :guest, :autoload, :user, :user_account, :models, :roles, :role_groups,
-        :engines, :users, :user_accounts, :categories
+        :engines, :users, :user_accounts, :categories, :adapters, :permits
       ]
     end
 
@@ -35,21 +35,26 @@ module CanTango
       }
     end
 
+    # Turn on all engines and enable compile adapter 
+    # i.e compilation of rules via sourcify
+    def enable_defaults!
+      engines.all :on
+      adapters.use :compiler
+    end
+
     def clear!
-      CanTango::Configuration.components.each do |c| 
+      CanTango::Configuration.components.each do |c|
         comp = send(c)
         comp.send(:clear!) if comp.respond_to? :clear!
       end
       engines.clear!
     end
 
-    CanTango::Configuration::Engines.available.each do |engine|
+    CanTango.config.engines.default_available.each do |engine|
       class_eval %{
-        def #{engine}
+        def #{engine}_engine
           engine(:#{engine})
         end
-
-        alias_method :#{engine.to_s.pluralize}, :#{engine}
       }
     end
 

data/lib/cantango/configuration/adapters.rb

@@ -0,0 +1,25 @@
+module CanTango
+  class Configuration
+    class Adapters < Registry
+  
+      include Singleton
+      
+      def adapter name
+        raise "Unknown adapter #{name}" if !available_adapters.include? name.to_sym
+        require "cantango/adapter/#{name}"
+      end
+
+      def use *names
+        names.each {|name| adapter name }
+      end
+
+      def available_adapters
+        [:moneta, :compiler]
+      end
+   
+    end
+  end
+end
+
+
+

data/lib/cantango/configuration/categories.rb

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

data/lib/cantango/configuration/engines.rb

@@ -6,18 +6,73 @@ module CanTango
       autoload_modules :Permission, :Permit, :Cache, :Store, :Engine
 
       include Singleton
+      include Enumerable
 
-      # engines available
-      def self.available
-        [:permit, :permission, :cache]
+      # engine registry is a simple hash
+      def register hash
+        hash.each_pair do |name, engine_class|
+          raise "Class must implement the CanTango Engine API. You can start by sublclassing CanTango::Engine" if !engine? engine_class
+          raise "Name of engine must be a String or Symbol" if !name.kind_of_label?
+          registered[name.to_sym] = engine_class
+        end
+      end
+
+      # engine factories ?
+      # :cache => Cantango::Ability::Cache
+      def registered
+        @registered ||= default_register
+      end
+
+      def unregister name
+        @registered = {} if name == :all
+        @registered.delete(name)
+      end
+
+      def default_register
+        {:permit => CanTango::PermitEngine, :permission => CanTango::PermissionEngine }
+      end
+
+      # defines the order of execution of engine in ability
+      def execution_order= *names
+        @execution_order = names.to_symbols.select {|name| available? name }
+      end
+
+      def execute_first name
+        execution_order.insert(0, name)
+      end
+
+      def execute_last name
+        execution_order.insert(-1, name)
+      end
+
+      def execute_before existing, name
+        index = execution_order.index(existing) || 0
+        execution_order.insert(index, name)
+      end
+
+      def execute_after existing, name
+        index = execution_order.index(existing)
+        index ? execution_order.insert(index +1, name) : execute_last(name)
+      end
+
+      def execution_order
+        @execution_order ||= (self.class.default_available - [:cache])
+      end
+
+      def self.default_available
+        [:cache, :permission , :permit]
+      end
+
+      def default_available
+        self.class.default_available
       end
 
       def available
-        self.class.available
+        (registered.keys + default_available).uniq
       end
 
       def available? name
-        self.class.available.include? name.to_sym
+        available.include? name.to_sym
       end
 
       def all state
@@ -25,23 +80,40 @@ module CanTango
       end
 
       def clear!
-        available.each {|engine| send(engine).reset! }
+        each {|engine| engine.reset! }
+        @registered = nil
+        @execution_order = nil
       end
 
-      def each &block
-        available.each {|engine| yield send(engine) if respond_to(engine) }
+      def each
+        available.each {|engine| yield send(engine) if respond_to?(engine) }
       end
 
-      available.each do |engine|
+      def active? name
+        active.include? name.to_sym
+      end
+
+      def active
+        available.select {|engine| send(engine).on? if respond_to?(engine) }
+      end
+
+      default_available.each do |engine|
         # def permission
         #   return Permission.instance
         # end
         class_eval %{
           def #{engine}
-            #{engine.to_s.camelize}.instance
-         end
+            CanTango::Configuration::Engines::#{engine.to_s.camelize}.instance
+          end
         }
       end
+
+      protected
+
+      # does it implement the basic Engine API?
+      def engine? engine_class
+        [:execute!, :ability].all? {|meth| engine_class.instance_methods.include? meth }
+      end
     end
   end
 end