cantango 0.8.0

data/lib/cantango/cancan/rule.rb

@@ -0,0 +1,6 @@
+module CanCan
+  class Rule
+    attr_accessor :block
+  end
+end
+

data/lib/cantango/configuration.rb

@@ -0,0 +1,83 @@
+require 'set'
+require 'singleton'
+
+module CanTango
+  class Configuration
+    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 :Users, :UserAccounts
+
+    include Singleton
+
+    def ability
+      @ability ||= conf::Ability.instance
+      @ability.default_class ||= CanTango::Ability
+      @ability
+    end
+
+    def self.components
+      [
+        :guest, :autoload, :user, :user_account, :models, :roles, :role_groups,
+        :engines, :users, :user_accounts, :categories
+      ]
+    end
+
+    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
+
+    def clear!
+      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|
+      class_eval %{
+        def #{engine}
+          engine(:#{engine})
+        end
+
+        alias_method :#{engine.to_s.pluralize}, :#{engine}
+      }
+    end
+
+    # allow either block or direct access
+    # engine(:permission) do |permission|
+    # engine(:permission).config_path
+    def engine name, &block
+      engine = find_engine(name)
+      yield engine if block
+      engine
+    end
+
+    attr_writer :localhost_list
+
+    def localhost_list
+      @localhost_list ||= ['localhost', '0.0.0.0', '127.0.0.1']
+    end
+
+    protected
+
+    def find_engine name
+      raise ArgumentError, "Must be label for an engine" if !name.kind_of_label?
+      name = name.to_s.singularize
+      engines.send(name) if engines.available? name
+    end
+
+    def conf
+      CanTango::Configuration
+    end
+  end
+end

data/lib/cantango/configuration/ability.rb

@@ -0,0 +1,13 @@
+module CanTango
+  class Configuration
+    class Ability
+      include Singleton
+      include ClassExt
+
+      include CanTango::Configuration::Factory
+    end
+  end
+end
+
+
+

data/lib/cantango/configuration/autoload.rb

@@ -0,0 +1,38 @@
+module CanTango
+  class Configuration
+    class Autoload
+      include Singleton
+
+      def clear!
+        @models = :on
+        @permits = :on
+      end
+
+      [:models, :permits].each do |name|
+        # def permission state = nil
+        #   raise ArgumentError unless [:on, :off].include? state
+        #   @permission = state
+        # end
+        class_eval %{
+          def #{name} state = nil
+            return #{name}? if !state
+            raise ArgumentError, "Must be :on or :off" unless [:on, :off].include? state
+            @#{name} = state
+          end
+        }
+         # def permits?
+        #   @permits ||= :on
+        #   @permits == :on
+        # end
+        class_eval %{
+          def #{name}?
+            @#{name} ||= :on
+            @#{name} == :on
+          end
+        }
+      end
+    end
+  end
+end
+
+

data/lib/cantango/configuration/categories.rb

@@ -0,0 +1,55 @@
+module CanTango
+  class Configuration
+    class Categories < HashRegistry
+      
+      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/engines.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engines
+      autoload_modules :Permission, :Permit, :Cache, :Store, :Engine
+
+      include Singleton
+
+      # engines available
+      def self.available
+        [:permit, :permission, :cache]
+      end
+
+      def available
+        self.class.available
+      end
+
+      def available? name
+        self.class.available.include? name.to_sym
+      end
+
+      def all state
+        available.each {|engine| send(engine).set state }
+      end
+
+      def clear!
+        available.each {|engine| send(engine).reset! }
+      end
+
+      def each &block
+        available.each {|engine| yield send(engine) if respond_to(engine) }
+      end
+
+      available.each do |engine|
+        # def permission
+        #   return Permission.instance
+        # end
+        class_eval %{
+          def #{engine}
+            #{engine.to_s.camelize}.instance
+         end
+        }
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,20 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engines
+      class Cache < Engine
+        include Singleton
+
+        def store &block
+          @store ||= ns::Store.new
+          @store.default_class ||= CanTango::Ability::Cache::MonetaCache
+          yield @store if block
+          @store
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,31 @@
+module CanTango
+  class Configuration
+    class Engines
+      class Engine
+        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
+end
+

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

@@ -0,0 +1,49 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engines
+      class Permission < Engine
+        include Singleton
+
+        def store &block
+          @store ||= ns::Store.new
+          @store.default_class = CanTango::PermissionEngine::YamlStore
+          yield @store if block
+          @store
+        end
+
+        def types
+          [:roles, :role_groups, :licenses, :users]
+        end
+
+        attr_reader :config_path
+
+        def config_path path = nil
+          return current_config_path if !path
+          raise "Must be a valid path to permission yaml file, was: #{path}" if !dir?(path)
+          @config_path = path
+        end
+
+        alias_method :config_path=, :config_path
+
+        private
+
+        def current_config_path
+          @config_path ||= File.join(::Rails.root.to_s, 'config') if rails?
+          @config_path or raise "Define path to config files dir!\n"
+        end
+
+        def rails?
+          defined?(::Rails) && ::Rails.respond_to?(:root)
+        end
+
+        def dir? dir
+          return false if !dir
+          File.directory?(dir)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+require 'singleton'
+
+module CanTango
+  class Configuration
+    class Engines
+      class Permit < Engine
+        include Singleton
+
+        def on?
+          @state ||= :on
+          @state == :on
+        end
+
+        def types
+          [:roles, :role_groups, :licenses, :users]
+        end
+
+        def special_permits
+          [:any, :system]
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,24 @@
+module CanTango
+  class Configuration
+    class Engines
+      class Store
+        include ClassExt
+
+        include CanTango::Configuration::Factory
+
+        def type_options
+          {:type => default_type}
+        end
+
+        def default_type= type
+          raise ArgumentError, "Must be a String or Symbol, was #{type}" if !type.kind_of_label?
+          @default_type = type.to_sym
+        end
+
+        def default_type
+          @default_type || :memory
+        end
+      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 "Factory must be a callable, either a lambda or 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
+
+