cantango-config 0.1.0

data/lib/cantango/configuration/candidate_registry.rb

@@ -0,0 +1,94 @@
+require 'singleton'
+require 'sugar-high/kind_of'
+
+module CanTango
+  class Configuration
+    class CandidateRegistry
+      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
+        NameRegistry.instance
+      end
+
+      def class_registry
+        ClassRegistry.instance
+      end
+
+      def value_methods
+        class_registry.value_methods
+      end
+
+      def value_types
+        class_registry.types
+      end
+
+      class NameRegistry < Registry
+        include Singleton
+      end
+
+      class ClassRegistry < Registry
+        include Singleton
+
+        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
+  end
+end

data/lib/cantango/configuration/categories.rb

@@ -0,0 +1,57 @@
+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)
+        models
+      end
+
+      def category label, &block
+        cat = Category.new self[label]
+        yield cat if block
+        cat
+      end
+
+      # test if a any of the categories contain the subject
+      def has_any? subject, &block
+        found = registered.any? {|cat, subjects| subjects.include? subject }
+        yield if found && block
+        found
+      end
+
+      # find the category of a subject if such a category exists
+      def category_names_of_subject subject, &block
+        categories_of_subject(subject).keys
+      end
+
+      # find the category of a subject if such a category exists
+      def categories_of_subject subject, &block
+        found_categories = registered.select do |cat, subjects|
+          subjects.include? subject.to_s
+        end
+        found_categories.empty? ? {} : found_categories
+      end
+
+      class Category
+        def initialize *subjects
+          @subjects = subjects.flatten
+        end
+
+        def subjects
+          @subjects ||= []
+        end
+
+        # test if a particular category has a certain subject
+        def has_any? subject, &block
+          found = subjects.include? subject
+          yield if found && block
+          found
+        end
+      end
+    end
+  end
+end

data/lib/cantango/configuration/debug.rb

@@ -0,0 +1,41 @@
+module CanTango
+  class Configuration
+    # Note: This config feature is currently not used, but could potentially be of use in the future
+    class Debug
+      include Singleton
+
+      def set state = :on
+        raise ArgumentError, "Must be :on or :off" unless !state || [:on, :off].include?(state)
+        @state = state || :on
+      end
+
+      def on?
+        @state == :on
+      end
+
+      def off?
+        !on?
+      end
+      
+      def debug_writer= proc
+        raise ArgumentError, "Debug writer must be callable (lambda or Proc), was: #{proc}" if !callable?(proc)
+        @debug_writer = proc
+      end
+      
+      def write msg
+        @debug_writer ||= Proc.new{|msg| puts msg}
+        @debug_writer.call(msg)
+      end
+      
+      protected
+      
+      def callable? obj
+        obj && obj.respond_to?(:call)
+      end      
+    end
+  end
+end
+
+
+
+

data/lib/cantango/configuration/engine.rb

@@ -0,0 +1,33 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engine
+      include Singleton
+      include CanTango::Configuration::Modes
+
+      def set state = :on
+        raise ArgumentError, "Must be :on or :off" unless !state || [:on, :off].include?(state)
+        @state = state || :on
+      end
+
+      def reset!
+        @state = nil
+      end
+
+      def on?
+        @state == :on
+      end
+
+      def off?
+        !on?
+      end
+
+      protected
+
+      def ns
+        CanTango::Configuration::Engines
+      end
+    end
+  end
+end

data/lib/cantango/configuration/engines.rb

@@ -0,0 +1,97 @@
+module CanTango
+  class Configuration
+    class Engines < HashRegistry
+      autoload_modules :Permission, :Engine
+
+      include Singleton
+      include Enumerable
+
+      # 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_s] = engine_class
+        end
+      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
+
+      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
+
+      def clear!
+        each {|engine| engine.reset! }
+        @registered = nil
+        @execution_order = nil
+      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
+        available.select {|engine| send(engine).on? if respond_to?(engine) }
+      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

data/lib/cantango/configuration/factory.rb

@@ -0,0 +1,59 @@
+module CanTango
+  class Configuration
+    module Factory
+      def clear!
+        @factory = nil
+      end
+
+      def factory factory = nil
+        raise ArgumentError, "Factory must be a callable (lambda or Proc), was: #{proc}" if !callable? factory
+        @factory = factory
+      end
+
+      alias_method :factory=, :factory
+
+      def factory_build obj = nil, opts = {}
+        factory_method = @factory ? :call_factory : :default_factory
+        send(factory_method, obj, opts)
+      end
+
+      def call_factory obj = nil, opts = {}
+        @factory.respond_to?(:call) ? @factory.call(obj, opts) : @factory
+      end
+
+      def default_factory obj = nil, opts = {}
+        raise "Default factory must be defined" if !default_class
+        default_class.new obj, options.merge(opts)
+      end
+
+      attr_reader :default_class
+
+      # must be a Class of type Cache (Base?)
+      def default_class= clazz
+        raise ArgumentError, "default must be a Class" if !is_class? clazz
+        @default_class = clazz
+      end
+
+      def options= options = {}
+        raise ArgumentError, "Must be a Hash, was #{options}" if !options.kind_of? Hash
+        @options = options
+      end
+
+      def options
+        @options ? type_options : type_options.merge(@options || {})
+      end
+
+      def type_options
+        {}
+      end
+
+      protected
+
+      def callable? obj
+        obj && obj.respond_to?(:call)
+      end
+    end
+  end
+end
+
+

data/lib/cantango/configuration/guest.rb

@@ -0,0 +1,57 @@
+module CanTango
+  class Configuration
+    class Guest
+      include Singleton
+
+      def clear!
+        @user = nil
+        @account = nil
+      end
+
+      def user user = nil, &block
+        return (@user || guest_user) if !user && !block
+        @user = user || yield
+      end
+
+      alias_method :user=, :user
+
+      def account account = nil, &block
+        return (@account || guest_account) if !account && !block
+        @account = account || yield
+      end
+      alias_method :user_account, :account
+      alias_method :account=, :account
+
+      def default_user?
+        has_guest? base_user_class
+      end
+
+      def default_account?
+        has_guest? base_account_class
+      end
+
+      protected
+
+      def guest_user
+        base_user_class.guest if default_user?
+      end
+
+      def guest_account
+        base_account_class.guest if default_account?
+      end
+
+      def has_guest? clazz
+        clazz && defined?(clazz) && clazz.respond_to?(:guest)
+      end
+
+      def base_user_class
+        CanTango.config.user.base_class
+      end
+
+      def base_account_class
+        CanTango.config.user_account.base_class
+      end
+    end
+  end
+end
+ 

data/lib/cantango/configuration/hash_registry.rb

@@ -0,0 +1,91 @@
+require 'singleton'
+require 'sugar-high/kind_of'
+
+module CanTango
+  class Configuration
+    class HashRegistry < Registry
+
+      def types= *types
+        raise "This is a Hash registry!"
+      end
+
+      def types
+        [Hash]
+      end
+
+      def value_methods
+        []
+      end
+
+      def value_types
+        []
+      end
+
+      def clean!
+        registered = Hashie::Mash.new
+      end
+      alias_method :clear!, :clean!
+
+      def default!
+        @registered = default
+      end
+
+      def << hash
+        raise "Must be a hash" if !hash.is_a? Hash
+        registered.merge!(hash) and return if value_methods.empty? && value_types.empty?
+        hash.each_pair do |key, value|
+          registered[key] = value if value_api.all?{|m| value.respond_to(m)} && value.any_kind_of?(value_types)
+        end
+      end
+
+      def [] label
+        raise "Must be a label" if !label.kind_of_label?
+        registered[label.to_s]
+      end
+
+      def []= label, value
+        raise "Must be a label" if !label.kind_of_label?
+        registered[label.to_s] = value
+      end
+
+      def register hash
+        raise "Must be a hash" if !hash.is_a? Hash
+        registered.merge! hash
+      end
+
+      def unregister name
+        @registered = {} if name == :all
+        @registered.delete(name)
+      end
+
+      def registered
+        @registered ||= default
+      end
+
+      def registered_names
+        registered.keys
+      end
+
+      def registered_values
+        registered.values
+      end
+
+      def registered? label
+        registered_names.map(&:to_s).include? label.to_s
+      end
+      alias_method :registered_name, :registered?
+
+      def registered_value? value
+        registered_values.include? value
+      end
+
+      def default
+        @default ||= Hashie::Mash.new
+      end
+
+      def default= hash
+        @default = Hashie::Mash.new hash
+      end
+    end
+  end
+end

data/lib/cantango/configuration/hooks.rb

@@ -0,0 +1,12 @@
+module CanTango
+  class Configuration
+    class Hooks < HashRegistry
+      include Singleton
+      
+      def value_methods
+        [:call]
+      end
+    end
+  end
+end
+

data/lib/cantango/configuration/localhosts.rb

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

data/lib/cantango/configuration/models/actions.rb

@@ -0,0 +1,26 @@
+module CanTango
+  class Configuration
+    class Models
+      class Actions
+        attr_reader :collection, :member
+
+        def initialize
+          @collection = []
+          @member = []
+        end
+
+        def actions_for type
+          send(type.to_sym) || []
+        end
+
+        def add_member action
+          @member << action.to_sym
+        end
+
+        def add_collection action
+          @collection << action.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/cantango/configuration/models/active_record.rb

@@ -0,0 +1,22 @@
+module CanTango
+  class Configuration
+    class Models
+      class ActiveRecord < Generic
+        def models
+          ::ActiveRecord::Base.descendants
+        rescue
+          table_models
+        end
+        
+        protected
+        
+        def table_models
+          ActiveRecord::Base.connection.tables do |t| 
+            t.classify.constantize 
+            nil
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/cantango/configuration/models/data_mapper.rb

@@ -0,0 +1,12 @@
+module CanTango
+  class Configuration
+    class Models
+      class DataMapper < Generic
+        def models
+          DataMapper::Resource.descendants
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/configuration/models/generic.rb

@@ -0,0 +1,12 @@
+module CanTango
+  class Configuration
+    class Models
+      class Generic
+        def available_models
+          models.map(&:name)
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/configuration/models/mongo.rb

@@ -0,0 +1,12 @@
+module CanTango
+  class Configuration
+    class Models
+      class Mongo
+        def available_models
+          models.map {|m| m.to_s.camelize }
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/configuration/models/mongo_mapper.rb

@@ -0,0 +1,11 @@
+module CanTango
+  class Configuration
+    class Models
+      module MongoMapper < Mongo
+        def models
+          MongoMapper.database.collections
+        end
+      end
+    end
+  end
+end

data/lib/cantango/configuration/models/mongoid.rb

@@ -0,0 +1,13 @@
+module CanTango
+  class Configuration
+    class Models
+      class Mongoid < Mongo
+        def models
+          ::Mongoid.database.collections
+        end
+      end
+    end
+  end
+end
+
+