troles 0.5.0 → 0.5.1

data/lib/trole_groups/config/schema.rb

@@ -0,0 +1,65 @@
+module TroleGroups
+  class Config
+    module Schema   
+      autoload :Helpers,            'trole_groups/config/schema/helpers'
+      autoload :RoleGroupHelpers,   'trole_groups/config/schema/role_group_helpers'      
+          
+      def configure_models
+        configure_generic
+        configure_field if auto_config?(:fields)
+        configure_relation if auto_config?(:relations)
+      end         
+      
+      def configure_generic                    
+        subject_class.send(:attr_accessor, role_field)  if generic? || orm == :generic # create troles accessor      
+      end
+      
+      # Adapter should customize this as needed 
+      def configure_field
+      end
+      
+      # Adapter should customize this as needed 
+      def configure_relation
+      end
+      
+      # Sets the role model to use
+      # allows different role subject classes (fx User Accounts) to have different role schemas
+      # @param [Class] the model class
+      def rolegroup_model= model_class
+        @rolegroup_model = model_class.to_s and return if model_class.any_kind_of?(Class, String, Symbol)
+        raise "The rolegroup model must be a Class, was: #{model_class}"
+      end
+      
+      # Gets the role model to be used
+      # see (#role_model=)
+      # @return [Class] the model class (defaults to Role)
+      def rolegroup_model
+        @rolegroup_model_found ||= begin
+          models = [@rolegroup_model, role_group_class_name].select do |class_name|
+            try_class(class_name.to_s.camelize)
+          end.compact
+          raise "No #{role_group_class_name} class defined, define a #{role_group_class_name} class or set which class to use, using the :rolegroup_model option on configuration" if models.empty?
+          models.first.to_s.constantize
+        end
+      end
+      
+      protected
+      
+      def role_group_class_name
+        'RoleGroup'
+      end
+      
+      def try_class clazz
+        begin
+          clazz = clazz.constantize if clazz.kind_of?(String)
+          clazz
+        rescue          
+          false
+        end
+      end
+
+      include Helpers
+      include RoleGroupHelpers
+    end
+  end
+end                                                          

data/lib/trole_groups/config/schema/helpers.rb

@@ -0,0 +1,11 @@
+module TroleGroups
+  class Config
+    module Schema
+      module Helpers
+        def self.included(base)
+          # base.send :include, Troles::Common::Config::Schema::Helpers
+        end
+      end
+    end
+  end
+end

data/lib/trole_groups/config/schema/role_group_helpers.rb

@@ -0,0 +1,11 @@
+module TroleGroups
+  class Config
+    module Schema
+      module RoleGroupHelpers
+        def rolegroup_class_name
+          rolegroup_model.to_s
+        end
+      end
+    end
+  end
+end

data/lib/trole_groups/config/valid_role_groups.rb

@@ -0,0 +1,21 @@
+module TroleGroups
+  class Config
+    module ValidRoleGroups    
+      def add_valid_rolegroups *rolegroups
+        valid_rolegroups =valid_rolegroups & rolegroups
+      end
+
+      def valid_rolegroups= *rolegroups
+        vrs = rolegroups.flatten.map{|r| r.to_s.alpha_numeric}.map(&:to_sym).uniq
+        raise ArgumentError, "The #{strategy} strategy can only accept 2 valid rolegroups" if (vrs.size > 2) && strategy == :bit_one
+        raise ArgumentError, "The rolegroup names you want to be valid are not valid rolegroup names. Must be alphanumeric, was: #{rolegroups.flatten}" if vrs.empty?
+        @valid_rolegroups ||= vrs
+      end
+
+      def valid_rolegroups
+        raise "No valid rolegroups defined" if !@valid_rolegroups || @valid_rolegroups.empty?
+        @valid_rolegroups      
+      end
+    end
+  end
+end

data/lib/trole_groups/macros.rb

@@ -0,0 +1,42 @@
+# 
+# @author Kristian Mandrup
+#
+# Macros that can be used directly on the role subject class 
+# These methods are added to the ruby core 'Module' module
+#
+# Usage:
+#   class User
+#     troles_strategy :bit_many
+#
+
+# puts "TroleGroups macros enabled!"
+
+module TroleGroups
+  module Macros
+    autoload :Configuration, 'trole_groups/macros/configuration'
+    
+    def trolegroups_strategy strategy, options = {}, &block
+      configuration = Configuration.new self, strategy, options
+
+      configuration.load_adapter
+      # puts "strategy module: #{configuration.strategy_module}" 
+      begin
+        self.send :include, configuration.strategy_module
+      rescue
+        puts "error loading strategy: #{configuration.strategy_module}"
+      end
+
+      configuration.define_hooks
+      configuration.apply_strategy_options!
+
+      if strategy == :bit_one 
+        trolegroups_config.valid_roles = [:user, :admin] # default binary roles 
+      end
+      
+      yield trolegroups_config if block_given?
+      trolegroups_config
+    end     
+  end  
+end
+
+Module.send :include, TroleGroups::Macros

data/lib/trole_groups/macros/configuration.rb

@@ -0,0 +1,89 @@
+module TroleGroups  
+  module Macros    
+    class Configuration
+      autoload :BaseLoader,     'trole_groups/macros/configuration/base_loader'
+      autoload :ConfigLoader,   'trole_groups/macros/configuration/config_loader'
+      autoload :StrategyLoader, 'trole_groups/macros/configuration/strategy_loader'
+      autoload :StorageLoader,  'trole_groups/macros/configuration/storage_loader'      
+      
+      attr_reader :strategy, :singularity, :orm, :auto_load, :options, :subject_class
+      
+      def initialize subject_class, strategy, options = {}
+        @subject_class = subject_class
+        @strategy = strategy
+        @orm = options[:orm] || Troles::Config.default_orm
+        @auto_load = options[:auto_load] || Troles::Config.auto_load?
+        options[:strategy] = strategy
+        @options = options
+      end
+
+      def strategy_module
+        strategy_loader.strategy_module
+      end
+            
+      def load_adapter
+        return false if !auto_load?
+
+        path = "#{namespace}/adapters/#{orm.to_s.underscore}"
+        begin
+          require path
+        rescue
+          raise "Adapter for :#{orm} could not be found at: #{path}"
+        end
+      end
+  
+      def apply_strategy_options!        
+        trolegroups_config.apply_options! options
+
+        # StrategyOptions.new(subject_class)
+        # extract_macros(options).each{|m| apply_macro m}
+      end      
+
+      def trolegroups_config
+        subject_class.trolegroups_config
+      end
+
+      def define_hooks
+        storage_class = storage_loader.storage_class
+        # puts "storage_class: #{storage_class}"
+        subject_class.send :define_method, :group_storage do 
+          @group_storage ||= storage_class
+        end
+        
+        config_class = config_loader.config_class
+        puts "config_class: #{config_class}" if Troles::Config.log_on
+        subject_class.singleton_class.class_eval %{
+          def trolegroups_config
+            @trolegroups_config ||= #{config_class}.new #{subject_class}, #{options.inspect}
+          end
+        }
+      end
+
+      protected
+
+      def namespace
+        'trole_groups'
+      end
+
+      def storage_loader
+        @storage_loader ||= StorageLoader.new strategy, orm
+      end
+
+      def config_loader
+        @config_loader ||= ConfigLoader.new strategy, orm
+      end
+
+      def strategy_loader
+        @strategy_loader ||= StrategyLoader.new strategy, orm
+      end
+
+      def auto_load?
+        (auto_load && orm) || false
+      end
+  
+      # def extract_macros options = {}
+      #   [:static_role].select {|o| options[o]}
+      # end
+    end
+  end
+end

data/lib/trole_groups/macros/configuration/base_loader.rb

@@ -0,0 +1,35 @@
+module TroleGroups::Macros
+  class Configuration  
+    class BaseLoader
+      attr_reader :strategy, :orm
+      
+      def initialize strategy, orm
+        @strategy = strategy
+        @orm = orm || Troles::Config.default_orm
+      end
+      
+      def try_module full_name
+        begin
+          full_name.constantize
+          true
+        rescue
+          false
+        end
+      end
+
+      def base_class
+        "BaseMany"
+      end
+
+      def namespace
+        'TroleGroups'
+      end
+
+      def orm_namespace
+        ns = namespace
+        ns << "::#{orm.to_s.camelize}" if orm
+        ns
+      end      
+    end
+  end
+end

data/lib/trole_groups/macros/configuration/config_loader.rb

@@ -0,0 +1,19 @@
+module TroleGroups::Macros
+  class Configuration  
+    class ConfigLoader < BaseLoader
+            
+      def initialize strategy, orm
+        super
+      end
+
+      def config_class
+        begin       
+          "#{orm_namespace}::Config".constantize
+        rescue
+          # use generic if no ORM specific strategy found!
+          "#{namespace}::Config".constantize
+        end        
+      end
+    end
+  end
+end

data/lib/trole_groups/macros/configuration/storage_loader.rb

@@ -0,0 +1,20 @@
+module TroleGroups::Macros
+  class Configuration  
+    class StorageLoader < BaseLoader
+
+      def initialize strategy, orm
+        super
+      end
+
+      def storage_class
+        begin
+          "#{orm_namespace}::Storage::#{strategy.to_s.camelize}".constantize
+        rescue
+          # use generic if no ORM specific strategy found!
+          "#{namespace}::Storage::#{strategy.to_s.camelize}".constantize
+        end        
+      end      
+    end
+  end
+end
+

data/lib/trole_groups/macros/configuration/strategy_loader.rb

@@ -0,0 +1,38 @@
+module TroleGroups::Macros
+  class Configuration  
+    class StrategyLoader < BaseLoader
+
+      def initialize strategy, orm
+        super
+      end      
+      
+      def strategy_module
+        @strategy_module ||= orm_strategy_module || generic_strategy_module        
+      end  
+
+      protected
+
+      def orm_strategy_module
+        @orm_strategy_module ||= begin         
+          mods_found = ["#{orm_namespace}::Strategy::#{strategy.to_s.camelize}", "#{namespace}::Strategy::#{base_class}"].select do |full_name|
+            try_module(full_name)
+          end
+          !mods_found.empty? ? mods_found.first.constantize : nil
+        end
+      end
+
+      def generic_strategy_module strategy_name, options
+        @generic_module ||= begin
+          base_class = base_name(strategy_name) 
+  
+          # use generic if no ORM specific strategy found!
+          ns = namespace(strategy_name, options)
+          mods_found = ["#{namespace}::Strategy::#{strategy.to_s.camelize}", "#{namespace}::Strategy::#{base_class}"].select do |full_name|
+            try_module(full_name)
+          end        
+          !mods_found.empty? ? mods_found.first.constantize : nil
+        end
+      end
+    end
+  end
+end

data/lib/trole_groups/macros/static_roles.rb

@@ -0,0 +1,9 @@
+module TroleGroups
+  module Macros
+    module StaticRoleGroups
+      def static_rolegroups?
+        true
+      end
+    end
+  end  
+end

data/lib/trole_groups/macros/strategy_options.rb

@@ -0,0 +1,21 @@
+module Troles  
+  module Macros    
+    class StrategyOptions
+      attr_reader :subject_class
+  
+      def initialize subject_class
+        @subject_class = subject_class
+      end
+
+      # @param [Symbol] name of the macro to run
+      def apply_macro name
+        # overrides default method that returns false
+        begin 
+          subject_class.send :include,  "Troles::Macros::#{strategy_name.to_s.camelize}".constantize
+        rescue
+        end
+      end
+    end
+  end
+end
+    

data/lib/trole_groups/operations.rb

@@ -0,0 +1,25 @@
+module TroleGroups
+  class Operations # < Troles::Common::Operations
+    autoload :Read,     'trole_groups/operations/read'
+    autoload :Write,    'trole_groups/operations/write'
+    
+    include Read
+    include Write
+
+    include Enumerable
+
+    attr_reader :rolegroup_subject
+    
+    # constructor
+    # @param [Object] the role subject, fx a User or UserAccount
+    def initialize rolegroup_subject
+      @rolegroup_subject = rolegroup_subject
+    end
+
+    # required method to act as enumerable
+    # iterates and yields all roles in the role list (Symbols)
+    def each
+      list.each { |rolegroup| yield rolegroup }
+    end        
+  end
+end

data/lib/trole_groups/operations/read.rb

@@ -0,0 +1,36 @@
+module TroleGroups
+  class Operations
+    module Read      
+      def roles
+        
+      end
+
+      def roles_for *names
+        rolegroup_subject.roles_for *names
+      end
+      
+      # The roles list of the role subject
+      # @return [Array<Symbol>] the list of roles
+      def list
+        rolegroup_subject.rolegroup_list
+      end
+
+      # Test if the role subject has exactly the given roles
+      # @param [Array<Symbol>] role list to test
+      # @return [true, false] true if role subject has exactly those roles, false otherwise 
+      def has? *rolegroups
+        list == rolegroups.to_symbols_uniq
+      end
+
+      # Which of the given roles are used by the role subject
+      # @param [Array<Symbol>] roles to test for inclusion      
+      #
+      # Usage:
+      #  - user.roles.used(:admin, :editor).include? :editor
+      #
+      def used *rolegroups
+        list & rolegroups.to_symbols_uniq
+      end
+    end
+  end
+end