troles 0.5.0 → 0.5.1

data/lib/trole_groups/adapters/active_record.rb

@@ -0,0 +1,8 @@
+module TroleGroups
+  module ActiveRecord
+    autoload :Config,     'trole_groups/adapters/active_record/config'
+    # autoload :Api,        'trole_groups/adapters/active_record/api'
+    autoload :Storage,    'trole_groups/adapters/active_record/storage'
+    autoload :Strategy,   'trole_groups/adapters/active_record/strategy'
+  end
+end

data/lib/trole_groups/adapters/active_record/strategy.rb

@@ -0,0 +1,11 @@
+module TroleGroups::ActiveRecord
+  module Strategy    
+    module BaseMany
+      # @param [Class] the role subject class for which to include the Role strategy (fx User Account)
+      #
+      def self.included(base)
+        base.send :include, TroleGroups::Strategy::BaseMany        
+      end      
+    end
+  end
+end

data/lib/trole_groups/adapters/mongoid.rb

@@ -0,0 +1,8 @@
+module TroleGroups
+  module Mongoid
+    autoload :Config,     'trole_groups/adapters/mongoid/config'
+    # autoload :Api,        'trole_groups/adapters/mongoid/api'
+    # autoload :Storage,    'trole_groups/adapters/mongoid/storage'
+    # autoload :Strategy,   'trole_groups/adapters/mongoid/strategy'
+  end
+end

data/lib/trole_groups/api.rb

@@ -0,0 +1,29 @@
+module TroleGroups
+  module Api
+    autoload :Core,       'trole_groups/api/core'
+    autoload :Cache,      'trole_groups/api/cache'
+    autoload :Config,     'trole_groups/api/config'
+    autoload :Event,      'trole_groups/api/event'
+    autoload :Read,       'trole_groups/api/read'
+    autoload :Write,      'trole_groups/api/write'
+    autoload :Validation, 'trole_groups/api/validation'
+
+
+    module ClassMethods
+      def apis
+        [:core, :cache, :config, :event, :read, :validation, :write]
+      end
+
+      def included(base)
+        apis.each do |api|
+          begin
+            base.include_and_extend :"#{api.to_s.camelize}"
+          rescue
+            puts "include error: #{api}"
+          end
+        end
+      end
+    end
+    extend ClassMethods
+  end
+end

data/lib/trole_groups/api/cache.rb

@@ -0,0 +1,13 @@
+#
+# @author Kristian Mandrup
+#
+# Caching Api to ensure the rolegroup list of a rolegroup subject is cached and invalidated on rolegroup change 
+#
+module TroleGroups::Api
+  module Cache
+    def invalidate_rolegroups_cache!
+      @rolegroup_list = nil
+      invalidate_role_cache!      
+    end
+  end  
+end

data/lib/trole_groups/api/config.rb

@@ -0,0 +1,4 @@
+module TroleGroups::Api
+  module Config
+  end  
+end

data/lib/trole_groups/api/core.rb

@@ -0,0 +1,50 @@
+module TroleGroups::Api
+  module Core
+    # Access to the Troles operations API
+    # @return [Troles::Operations] the operations API object 
+    def rolegroups
+      @rolegroups ||= TroleGroups::Operations.new(self)
+    end       
+
+    # Sets the roles of the subject
+    # (see #set_roles)
+    def rolegroups= *new_rolegroups
+      rolegroups.set_rolegroups new_rolegroups
+    end       
+
+    # If this role subject instance should have static (immutable) roles
+    # @return [true, false] defaults to false so a role subject is allowed to change roles 
+    def static_roles?
+      false
+    end
+
+    def trolegroups_config
+      self.class.trolegroups_config      
+    end
+      
+    module ClassMethods            
+
+      def rolegroup_field
+        trolegroups_config.rolegroup_field
+      end
+    
+      def valid_rolegroups
+        trolegroups_config.valid_roles
+      end
+
+      # # TODO: make sure alphanumeric only
+      # def valid_roles= *roles
+      #   troles_config.valid_roles = *roles
+      # end
+
+      # If all role subjects using this strategy should have static (immutable) roles
+      #
+      # @note Should also proxy Config object?      
+      #
+      # @return [true, false] if role subjects have static roles or not (default: false)
+      def static_roles?
+        false # trolegroups_config.static_roles?
+      end           
+    end
+  end
+end

data/lib/trole_groups/api/event.rb

@@ -0,0 +1,29 @@
+module TroleGroups::Api
+  module Event
+    # a change to the roles of the user should be published to an event handler
+    # this can be used to update both the Role cache of the user and fx the RolePermit cache.
+    # Both (and potentially others, fx for Role Groups) can subscribe to this event!
+    def update_role_groups
+      publish_change(:role_groups) if field_changed?(rolegroups_field)
+    end
+
+    # check if a field on the model changed
+    # See http://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+    def field_changed? name
+     send :"#{name}_changed?"
+    end
+
+    # can be customized
+    # here uses singleton EventManager
+    def publish_change event
+      send :invalidate_rolegroups_cache! if event == :role_groups
+      event_manager.publish_change event, :from => self
+    end
+    
+    protected
+    
+    def event_manager
+      Troles::Common::EventManager
+    end      
+  end
+end

data/lib/trole_groups/api/read.rb

@@ -0,0 +1,56 @@
+module TroleGroups::Api
+  module Read
+    def roles_from_rolegroups
+      group_store.display_roles
+    end
+    
+    def roles_for *names
+      group_store.display_roles_for *names
+    end
+    
+    # any? on rolegroups_list
+    def in_rolegroup? rolegroup
+      rolegroup_list.include? rolegroup.to_sym
+    end
+    alias_method :has_rolegroup?, :in_rolegroup?
+
+    # rolegroup_list has one element which is rolegroup
+    def only_in_rolegroup? rolegroup
+      rolegroup_list.first == rolegroup.to_sym && rolegroup_list.size == 1      
+    end
+
+    # subtraction of role_groups from rolegroups_list is empty
+    def in_rolegroups? *rolegroups
+      (rolegroups.to_symbols - rolegroup_list).empty?
+    end
+    alias_method :has_rolegroups?, :in_rolegroups?
+
+    # union of rolegroups and rolegroups_list is not empty
+    def in_any_rolegroup? *rolegroups
+      !(rolegroup_list & rolegroups.to_symbols).empty?
+    end
+    alias_method :has_any_rolegroup?, :in_any_rolegroup?
+
+    # return roles of that rolegroup
+    def roles_of rolegroup
+      raise "Pending"
+    end
+
+    # return Set of symbols,where each symbol is a rolegroup name
+    # This set should be cached and only invalidated when the user has a change of roles
+    def rolegroup_list
+      @rolegroup_list ||= begin
+        group_store.display_rolegroups
+      end
+    end
+    
+    # Ensures that the common API methods always have a common underlying model to work on
+    # @note This Set should be cached and only invalidated when the user has a change of roles    
+    # @return Array<Symbol> Set of role names
+    def role_list        
+      @role_list ||= begin
+        (store.display_roles | group_store.display_roles)
+      end
+    end    
+  end
+end

data/lib/trole_groups/api/validation.rb

@@ -0,0 +1,44 @@
+#
+# @author Kristian Mandrup
+# 
+# Common Validation API
+#
+module TroleGroups::Api
+  module Validation
+
+    # @return [Symbol, false] returns the role if it's valid, false if not
+    def check_valid_rolegroup? rolegroup
+      return rolegroup if valid_rolegroups.include? rolegroup.to_sym
+      false
+    end
+
+    # @return [Array<Symbol>] returns the valid roles or empty list if no valid roles
+    def check_valid_rolegroups? *rolegroups
+      valid_rolegroups & rolegroups.to_symbols     
+    end
+    
+    protected
+
+    # Ensures the role is valid
+    # @param [Symbol] role name
+    # @return [Symbol, false, Error] a valid role name, false if invalid, or Error on some error
+    def make_valid_rolegroup rolegroup
+      raise ArgumentError, "Rolegroup to set must be a Symbol or String" if !rolegroup.kind_of_label?
+      check_valid_rolegroup? rolegroup.to_s.alpha_numeric
+    end
+
+    # Ensures the role are valid
+    # @param [Symbol] list of roles
+    # @return [Array<Symbol>] the valid roles from the list of roles given
+    def make_valid_rolegroups *rolegroups      
+      rolegroups = rolegroups.to_symbols_uniq
+      return [] if rolegroups.empty?                
+      check_valid_rolegroups? rolegroups.map{|r| r.to_s.alpha_numeric}
+    end
+
+    # @return [Array<Symbol>] the valid roles of the role subject
+    def valid_rolegroups
+      self.class.trolegroups_config.valid_rolegroups
+    end
+  end
+end

data/lib/trole_groups/api/write.rb

@@ -0,0 +1,60 @@
+module TroleGroups::Api
+  module Write
+    # Add a single new rolegroup to the rolegroups of the subject
+    # @param  [Symbol] rolegroup to add
+    # @return (see #add_rolegroups)
+    def add_rolegroup rolegroup_name
+      raise ArgumentError, "Take a single rolegroup name, was: #{rolegroup_name}" if !rolegroup_name || !rolegroup_name.kind_of_label?
+      add_rolegroups rolegroup_name
+    end  
+
+    # Remove a single rolegroup from the rolegroups of the subject
+    # @param  [Symbol] rolegroup to remove
+    # @return (see #remove_rolegroups)
+    def remove_rolegroup rolegroup_name
+      raise ArgumentError, "Take a single rolegroup name, was: #{rolegroup_name}" if !rolegroup_name || !rolegroup_name.kind_of_label?
+      remove_rolegroups rolegroup_name
+    end    
+
+    # Adds a set of new rolegroups to the rolegroups of the subject
+    # @param  [Array<Symbol>] list of rolegroups to add
+    # @return [true, false, Error] true if ok, false if static or invalid, Error on some error
+    def add_rolegroups *new_rolegroups      
+      group_store.set_rolegroups (rolegroup_list | new_rolegroups.to_symbols_uniq) # Set Union (joined set)
+    end  
+
+    # Removes a set of new rolegroups to the rolegroups of the subject
+    # (see #add_rolegroups)
+    def remove_rolegroups *the_rolegroups
+      group_store.set_rolegroups (rolegroup_list - the_rolegroups.to_symbols_uniq)
+    end  
+
+    # Sets new rolegroups for the subject
+    # @param [Array<Symbol>] list of rolegroup names
+    # @return [true, false, Error] true if set ok, false if any rolegroups were invalid, Error on some error 
+    def set_rolegroups *rolegroups
+      rolegroups_to_set = make_valid_rolegroups(*rolegroups).flat_uniq
+      return false if !rolegroups_to_set || rolegroups_to_set.empty?
+      group_store.set_rolegroups(rolegroups_to_set) 
+    end  
+
+    # Clears all the rolegroups of the subject
+    # @return [true, false, Error] true if ok, false if rolegroups are static, Error on some error 
+    def clear_rolegroups!
+      group_store.clear!
+    end  
+  
+    module ClassMethods
+      # Sets which rolegroups are valid for the rolegroup subject class (fx User or UserAccount)
+      #
+      # @note this in effect limits what rolegroups can be assigned to any instance of the class
+      #
+      # @param [Array<Symbol>] list of rolegroup names
+      def set_valid_rolegroups *rolegroups
+        rolegroups = rolegroups.to_symbols_uniq
+        raise ArgumentError, "Roles must contain Symbols or Strings" if rolegroups.empty?
+        @valid_rolegroups = rolegroups
+      end      
+    end          
+  end
+end

data/lib/trole_groups/config.rb

@@ -0,0 +1,134 @@
+module TroleGroups
+  class Config        
+    autoload :ValidRoleGroups,      'trole_groups/config/valid_role_groups'        
+    autoload :Schema,               'trole_groups/config/schema'
+
+    def self.sub_modules
+      [:valid_role_groups, :schema] # , :static_roles, , 
+    end
+    
+    sub_modules.each do |name|
+      begin
+        self.send :include, "TroleGroups::Config::#{name.to_s.camelize}".constantize
+      rescue Error => e 
+        puts "include sub-module #{name}, error: #{e}"
+      end
+    end
+
+    attr_accessor :subject_class, :strategy, :log_on, :generic, :auto_relations
+    attr_writer   :orm
+
+    def initialize subject_class, options = {}
+      @subject_class = subject_class
+      # set instance var for each pair in options
+      apply_options! options
+    end
+
+    def apply_options! options = {}
+      options.each_pair do |key, value| 
+        send("#{key}=", value) if self.respond_to?(:"#{key}")
+      end      
+    end
+
+    def configure! options = {}
+      apply_options! options
+      configure_models if auto_config?(:models)
+    end
+
+    class << self
+      attr_reader :default_orm, :auto_load
+      attr_accessor :log_on
+
+      def log_on?
+        log_on || false
+      end
+
+      def default_orm= orm
+        @default_orm ||= orm
+      end
+
+      def auto_load= mode
+        raise "Autoload must be set to true or false" if ![true, false].include? mode
+        @auto_load = mode
+      end
+
+      def auto_load?
+        @auto_load
+      end      
+
+      def auto_config
+        auto_config_setings
+      end 
+
+      def auto_config? name
+        auto_config_setings[name]
+      end
+
+      protected
+
+
+      def auto_config_setings
+        @auto_config_setings ||= auto_config_defaults
+      end
+
+      # default auto_config settings
+      def auto_config_defaults
+        {:models => true, :relations => true, :fields => true}
+      end      
+    end
+
+    def log_on?
+      log_on || Troles::Config.log_on
+    end
+
+    def auto_config
+      auto_config_setings 
+    end 
+
+    def auto_config? name
+      return auto_config_setings[name] if !auto_config_setings[name].nil?
+      Troles::Config.auto_config?(name)
+    end
+
+
+    def auto_config_setings
+      @auto_config_setings ||= {}
+    end
+    
+    def role_field
+      @role_field ||= begin
+        default_role_field
+      end
+    end
+    alias_method :rolegroup_field, :role_field
+
+    def role_field= field_name
+      name = field_name.to_s.alpha_numeric.to_sym
+      raise ArgumentException, "Not a valid role field name: #{field_name}"  if !valid_field_name?(name)
+      @role_field ||= name
+    end
+    alias_method :rolegroup_field=, :role_field=
+
+    def default_role_field
+      :trole_groups
+    end
+
+    def orm
+      @orm || self.class.default_orm
+    end
+
+    def singularity
+      @singularity ||= (strategy =~ /_many$/) ? :many : :one
+    end
+
+    # def singularity= value
+    #   raise ArgumentError, "Must be :many or :one" if ![:one, :many].include?(value)      
+    #   @singularity ||= value
+    # end
+
+    def generic?
+      return true if orm.nil?
+      @generic.nil? ? false : @generic
+    end
+  end  
+end