cantango-config 0.1.9.2 → 0.2.0

data/lib/cantango/config/class_methods.rb

@@ -0,0 +1,27 @@
+module CanTango
+  class Config
+    module ClassMethods
+      def self.extended base
+        base.class_eval do
+          components.each do |conf_module|
+            class_eval %{
+              def #{conf_module} &block
+                conf = conf::#{conf_module.to_s.camelize}.instance
+                yield conf if block
+                conf
+              end
+            }
+          end
+        end
+      end
+      
+      def components
+        [
+          :guest, :autoload, :user, :account, :models, :modes, :roles, :role_groups,
+          :engines, :users, :accounts, :categories, :adapters, :debug,
+          :localhosts, :orms, :hooks, :helpers
+        ]
+      end
+    end
+  end
+end

data/lib/cantango/{configuration → config}/debug.rb

@@ -1,5 +1,5 @@
 module CanTango
-  class Configuration
+  class Config
     # Note: This config feature is currently not used, but could potentially be of use in the future
     class Debug
       include Singleton

data/lib/cantango/config/engines.rb

@@ -0,0 +1,47 @@
+module CanTango
+  class Config
+    class Engines
+      sweetload :Order, :Available
+      
+      include Singleton
+      include Enumerable
+      include Order
+      include Available
+      include CanTango::Registry::Hash::InstanceMethods
+
+      # engine registry is a simple hash
+      def register hash
+        hash.each_pair do |name, engine_class|
+          raise "Class must implement the CanTango::Engine API." unless self.class.valid_engine?(engine_class)
+          raise "Name of engine must be a String or Symbol" if !name.kind_of_label?
+          registered[name.to_s] = engine_class
+        end
+      end
+
+      def clear!
+        each {|engine| engine.reset! }
+        @registered = nil
+        clear_order!
+      end
+
+      def each
+        available.each {|engine| yield send(engine) if respond_to?(engine) }
+      end
+
+      def active? name
+        active.include? name.to_sym
+      end
+
+      def active_list
+        available.select {|engine| send(engine).on? if respond_to?(engine) }
+      end
+
+      protected
+
+      # does it implement the basic Engine API?
+      def self.valid_engine? engine_class
+        [:execute!, :ability].all? {|meth| engine_class.instance_methods.include? meth }
+      end
+    end
+  end
+end

data/lib/cantango/config/engines/available.rb

@@ -0,0 +1,19 @@
+class CanTango::Config::Engines
+  module Available
+    def available
+      registered_names
+    end
+
+    def available? name
+      available.include? name.to_s
+    end
+
+    def all state
+      available.each {|engine| send(engine).set state }
+    end
+
+    def any? state
+      available.any? {|engine| send(engine).send(:"#{state}?") if respond_to?(engine) }
+    end
+  end
+end

data/lib/cantango/config/engines/order.rb

@@ -0,0 +1,48 @@
+module CanTango
+  class Config
+    class Engines
+      module Order
+        def clear_order!
+          @execution_order = nil
+        end
+        
+        # defines the order of execution of engine in ability
+        def set_execution_order *names        
+          @execution_order = names.flatten.uniq.map(&:to_s).select {|name| available? name }
+        end
+
+        def dont_execute name
+          execution_order.delete(name.to_s)
+        end
+
+        def execute_first name
+          dont_execute name
+          execution_order.insert(0, name.to_s)
+        end
+
+        def execute_last name
+          dont_execute name
+          execution_order.insert(-1, name.to_s)
+        end
+
+        def execute_before existing, name
+          dont_execute name
+          index = execution_order.index(existing.to_s) || 0
+          execution_order.insert(index, name.to_s)
+          execution_order.compact!
+        end
+
+        def execute_after existing, name
+          dont_execute name
+          index = execution_order.index(existing.to_s)
+          index ? execution_order.insert(index +1, name.to_s) : execute_last(name)
+          execution_order.compact!
+        end
+
+        def execution_order
+          @execution_order ||= (available - [:cache])
+        end
+      end
+    end
+  end
+end

data/lib/cantango/{configuration → config}/factory.rb

@@ -1,5 +1,5 @@
 module CanTango
-  class Configuration
+  class Config
     module Factory
       def clear_factory!
         @factory = nil

data/lib/cantango/{configuration → config}/guest.rb

@@ -1,5 +1,5 @@
 module CanTango
-  class Configuration
+  class Config
     class Guest
       include Singleton
 
@@ -15,11 +15,10 @@ module CanTango
 
       alias_method :user=, :user
 
-      def account account = nil, &block
-        return (@account || guest_account) if !account && !block
-        @account = account || yield
+      def account acc = nil, &block
+        return (@account || acc) if !acc && !block
+        @account = acc || yield
       end
-      alias_method :user_account, :account
       alias_method :account=, :account
 
       def default_user?
@@ -49,7 +48,7 @@ module CanTango
       end
 
       def base_account_class
-        CanTango.config.user_account.base_class
+        CanTango.config.account.base_class
       end
     end
   end

data/lib/cantango/config/helpers.rb

@@ -0,0 +1,17 @@
+module CanTango
+  class Config
+    class Helpers
+      include Singleton
+
+      def enable *names
+        names = names.to_symbols
+        enable_rest if names.include? :rest
+      end
+
+      def enable_rest
+        raise 'ApplicationController not defined' if !defined?(::ApplicationController)
+        ::ApplicationController.send :include, CanTango::Rails::Helpers::RestHelper
+      end
+    end
+  end
+end

data/lib/cantango/{configuration → config}/hooks.rb

@@ -1,8 +1,8 @@
 module CanTango
-  class Configuration
-    class Hooks < Registry::Hash
+  class Config
+    class Hooks < CanTango::Registry::Hash
       include Singleton
-      
+
       def value_methods
         [:call]
       end

data/lib/cantango/{configuration → config}/localhosts.rb

@@ -1,12 +1,11 @@
 module CanTango
-  class Configuration
-    class Localhosts < Registry::Base
+  class Config
+    class Localhosts < CanTango::Registry::Base
       include Singleton
-      
+
       def default
         @default ||= ['localhost', '0.0.0.0', '127.0.0.1']
       end
     end
   end
-end
-
+end

data/lib/cantango/{configuration → config}/models.rb

@@ -1,15 +1,24 @@
 module CanTango
-  class Configuration
+  class Config
     class Models
-      autoload_modules :Generic, :ActiveRecord, :DataMapper, :Mongo, :MongoMapper, :Mongoid
-      autoload_modules :Actions
+      sweetload :Generic, :ActiveRecord, :DataMapper, :Mongo, :MongoMapper, :Mongoid
+      sweetload :Actions
 
       include CanTango::Helpers::Debug
       include Singleton
       include ClassExt
 
+      def use *names
+        names = names.select_symbols
+        if names.include? :guest_user
+          require 'cantango/model/user/guest'
+        end
+      rescue LoadError => e
+        debug e.message
+      end
+
       def actions
-        @actions ||= Registry::Hash.new
+        @actions ||= CanTango::Registry::Hash.new
       end
 
       def by_reg_exp reg_exp
@@ -34,13 +43,13 @@ module CanTango
         @excluded ||= []
       end
 
-      def available_models
-        all_models - excluded.map {|m| m.to_s.camelize}
+      def available
+        all - excluded.map {|m| m.to_s.camelize}
       end
 
       protected
 
-      def all_models
+      def all
         CanTango.config.orms.registered.compact.inject([]) do |result, orm|
           adapter = adapter_for(orm)
           result << (adapter.models.map(&:name) if adapter)

data/lib/cantango/{configuration → config}/orms.rb

@@ -1,6 +1,6 @@
 module CanTango
-  class Configuration
-    class Orms < Registry::Base
+  class Config
+    class Orms < CanTango::Registry::Base
       include Singleton
     end
   end

data/lib/cantango/{configuration → config}/user.rb

@@ -1,5 +1,5 @@
 module CanTango
-  class Configuration
+  class Config
     class User
       include Singleton
 

data/lib/cantango/{configuration → config}/users.rb

@@ -1,6 +1,6 @@
 module CanTango
-  class Configuration
-    class Users < Registry::Clazz
+  class Config
+    class Users < CanTango::Registry::Clazz
       include Singleton
       
       def register_user clazz

data/lib/cantango/registry.rb

@@ -0,0 +1,5 @@
+module CanTango
+  module Registry
+    sweetload :Base, :Hash, :Clazz
+  end
+end

data/lib/cantango/{configuration/registry → registry}/base.rb

@@ -2,10 +2,10 @@ require 'singleton'
 require 'sugar-high/kind_of'
 
 module CanTango
-  class Configuration
-    module Registry
-      class Base
-        attr_writer   :default
+  module Registry
+    class Base
+      module InstanceMethods
+        attr_writer   :default, :available
         attr_accessor :registered
 
         def types= *types
@@ -21,6 +21,10 @@ module CanTango
           @registered = []
         end
 
+        def reset!
+          @registered = default
+        end
+
         alias_method :clear!, :clean!
 
         def default!
@@ -49,7 +53,17 @@ module CanTango
         def default
           @default ||= []
         end
+        
+        def valid? label
+          return available.include?(label) if respond_to?(:available) && !available.empty?
+          true
+        end
+
+        def available
+          []
+        end
       end
+      include InstanceMethods
     end
   end
 end

data/lib/cantango/registry/clazz.rb

@@ -0,0 +1,92 @@
+require 'singleton'
+require 'sugar-high/kind_of'
+
+module CanTango::Registry
+  class Clazz
+    module InstanceMethods
+      def register label, value
+        raise "first arg must be a label, was: #{label}" if !label.kind_of_label?
+        raise "second arg must be a valid Class, was: #{value}" if !valid? value
+        name_registry.register label.to_sym
+        class_registry.register value
+      end
+      alias_method :[]=, :register
+
+      def << hash
+        raise "Must be a hash" if !hash.is_a?(::Hash)
+        hash.each_pair do |key, value|
+          register key, value
+        end
+      end
+
+      def registered
+        name_registry.registered
+      end
+      alias_method :registered_names, :registered
+
+      def clean!
+        name_registry.clean!
+        class_registry.clean!
+      end
+      alias_method :clear!, :clean!
+
+      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
+        @name_registry ||=NameRegistry.new
+      end
+
+      def class_registry
+        @class_registry ||= ClassRegistry.new
+      end
+
+      def value_methods
+        class_registry.value_methods
+      end
+
+      def value_types
+        class_registry.types
+      end
+
+      class NameRegistry < CanTango::Registry::Base
+      end
+
+      class ClassRegistry < CanTango::Registry::Base
+        def types
+          [Class]
+        end
+
+        def value_methods
+          []
+        end
+      end
+
+      protected
+
+      def valid? value
+        valid_by_type?(value) && valid_by_methods?(value)
+      end
+
+      def valid_by_type? value
+        return true if value_types.blank?
+        value.any_kind_of?(*value_types)
+      end
+
+      def valid_by_methods? value
+        return true if value_methods.blank?
+        value_methods.all?{|m| value.respond_to(m)}
+      end
+    end
+    include InstanceMethods
+  end
+end