troles 0.5.0 → 0.5.1

data/lib/trole_groups/operations/write.rb

@@ -0,0 +1,42 @@
+# @author Kristian Mandrup
+module TroleGroups
+  class Operations
+    module Write
+      
+      # Test role_groups equality
+      # @param [Array<Symbol>] role_groups list to test
+      def == *role_groups
+        rolegroup_subject.rolegroup_list == role_groups.to_symbols_uniq
+      end
+      alias_method :equal, :"=="
+      alias_method :same_as, :"=="
+
+      # Add a set of role_groups to the role subject
+      # @param  [Array<Symbol>] role_groups list to add
+      # @return [true, false, Error] true if added, false if static or invalid, Error on some error
+      def + *role_groups
+        rolegroup_subject.add_role_groups role_groups.to_symbols_uniq
+      end
+      alias_method :<<, :+
+      alias_method :add, :+
+      alias_method :add!, :+                           
+
+      # Remove a set of role_groups from the role subject
+      # @param  [Array<Symbol>] role_groups list to add
+      # @return [true, false, Error] true if removed, false if static or invalid, Error on some error
+      def - *role_groups
+        rolegroup_subject.remove_role_groups role_groups.to_symbols_uniq
+      end
+      alias_method :remove, :-
+      alias_method :remove!, :-
+
+      # Clear all the role_groups from the role subject
+      # @param  [Array<Symbol>] role_groups list to add
+      # @return [true, false, Error] true if removed, false if static or invalid, Error on some error
+      def clear
+        rolegroup_subject.clear_role_groups!
+      end    
+      alias_method :clear!, :clear
+    end
+  end
+end

data/lib/trole_groups/storage.rb

@@ -0,0 +1,27 @@
+module TroleGroups
+  module Storage
+    autoload :BaseMany,   'trole_groups/storage/base_many'
+    # autoload :BitMany,    'trole_groups/storage/bit_many'
+    autoload :EmbedMany,  'trole_groups/storage/embed_many'
+    autoload :RefMany,    'trole_groups/storage/ref_many'
+    # autoload :StringMany, 'trole_groups/storage/string_many'        
+    
+    class BaseMany < Troles::Common::Storage
+      protected
+      
+      # get matching list of Role instances
+      # @param  [Array<Symbol>] list of role names to find Roles for
+      # @return [Array<Role>] references to Role instances
+      def find_rolegroups *rolegroups
+        rolegroup_model.where(:name => rolegroups.flatten).all
+      end
+
+      # get list of embedded Role instances
+      # @param  [Array<Symbol>] list of role names
+      # @return [Array<Role>] Role instances generated      
+      def rolegroups_to_embed *rolegroups
+        raise "Must be implemented by embed storage to generate a set of rolegroups to embed"
+      end           
+    end        
+  end
+end

data/lib/trole_groups/storage/base_many.rb

@@ -0,0 +1,93 @@
+# @author Kristian Mandrup
+#
+# Troles base storage for Many roles strategies
+#
+module TroleGroups
+  module Storage
+    class BaseMany
+      attr_reader :rolegroup_subject
+
+      # initializes storage with reference to role subject
+      # @param [Object] the role subject (fx a User or UserAccount) 
+      def initialize rolegroup_subject
+        @rolegroup_subject = rolegroup_subject
+      end      
+
+      # valid roles of the role subjects class (fx account - i.e the account rules!)
+      # @return [Array<Symbol>] the list of valid roles
+      def valid_roles
+        rolegroup_subject.class.valid_roles
+      end        
+
+      # name/type of storage
+      # @return [Symbol]
+      def name
+        :generic
+      end 
+
+      # sets the value of the role field (@trole or @troles) and persists the value (in the data store)
+      # @param [Object] the value to set on the role field of the role subject
+      def set_ds_field value
+        return if ds_field_value == value
+        rolegroup_subject.send(:"#{ds_field_name}=", value)
+        persist_role_changes!
+      end
+
+      # the name of the role field
+      # @return [Symbol] the name
+      def ds_field_name
+        rolegroup_field
+      end
+
+      # the current value of the role field
+      # @return [Object] the value
+      def ds_field_value
+        rolegroup_subject.send(ds_field_name)
+      end      
+
+      # Attempts to persist the role field changes
+      # @return [true, false, error] true if saved, false if no save! method, Error on some error
+      def persist_role_changes!  
+        return false if !rolegroup_subject.respond_to? :save!
+        rolegroup_subject.save!
+        rolegroup_subject.publish_change :role_groups
+      end 
+
+      protected
+
+      def trolegroups_config
+        rolegroup_subject.class.trolegroups_config
+      end
+
+      def rolegroup_field      
+        trolegroups_config.rolegroup_field
+      end
+
+      def rolegroup_model
+        trolegroups_config.rolegroup_model
+      end
+
+      def rolegroup_list
+        rolegroup_subject.rolegroup_list
+      end
+
+      def role_list
+        rolegroup_subject.role_list
+      end
+            
+      # get matching list of Role instances
+      # @param  [Array<Symbol>] list of role names to find Roles for
+      # @return [Array<Role>] references to Role instances
+      def find_rolegroups *names
+        rolegroup_model.where(:name => names.flatten).all
+      end
+
+      # get list of embedded Role instances
+      # @param  [Array<Symbol>] list of role names
+      # @return [Array<Role>] Role instances generated      
+      def rolegroups_to_embed *roles
+        raise "Must be implemented by embed storage to generate a set of roles to embed"
+      end           
+    end        
+  end
+end

data/lib/trole_groups/storage/embed_many.rb

@@ -0,0 +1,58 @@
+# @author Kristian Mandrup
+#
+# Many role storage for storing (embedding) multiple Role instances in a list on the role subject
+#
+# @note all methods potentially operate directly on values in the data store
+#
+module TroleGroups::Storage
+  class EmbedMany < BaseMany
+
+    # constructor
+    # @param [Object] the role subject
+    def initialize rolegroupsubject
+      super
+    end
+
+    def rolegroups_to_embed *rolegroups
+      rolegroups.flatten.inject([]) do |res, role| 
+        res << create_role(role)
+        res
+      end
+    end           
+
+    # display the rolegroups as a list of symbols
+    # @return [Array<Symbol>] rolegroups list
+    def display_rolegroups
+      return [] if !ds_field_value?
+      ds_field_value.map{|rolegroup| rolegroup.name.to_sym }
+    end
+
+    # is it set?
+    def ds_field_value?
+      ds_field_value && !ds_field_value.empty?
+    end    
+  
+    # saves the rolegroups for the role subject in the data store
+    # @param [Array<Symbol>] rolegroups list    
+    def set_rolegroups *rolegroups
+      # creates and embeds new Role instances from symbols
+      set_ds_field rolegroups_to_embed(*rolegroups)
+    end  
+
+    # clears the role of the user in the data store
+    def clear!
+      set_ds_field []
+    end  
+  
+    # sets the role to its default state
+    def set_default_role!
+      clear!
+    end
+    
+    protected
+    
+    def create_role name
+      rolegroup_model.create name
+    end
+  end
+end

data/lib/trole_groups/storage/ref_many.rb

@@ -0,0 +1,47 @@
+module TroleGroups::Storage
+  class RefMany < BaseMany
+    def initialize rolegroup_subject
+      super
+    end
+
+    def display_roles
+      display_roles_for rolegroup_list
+    end
+
+    def display_roles_for *names
+      groups = find_rolegroups names.to_symbols_uniq
+      groups.inject([]) {|res, group| res << group.roles }.flat_uniq
+    end
+
+    # display the roles as a list of symbols
+    # @return [Array<Symbol>] roles list
+    def display_rolegroups
+      return [] if !ds_field_value?
+      ds_field_value.flatten.map do |rolegroup| 
+        rolegroup.name.to_sym 
+      end
+    end
+
+    # is it set?
+    def ds_field_value?
+      ds_field_value && !ds_field_value.empty?
+    end      
+    
+    # saves the role for the user in the data store
+    def set_rolegroups *rolegroups
+      # finds and sets references to existing Role instances from symbols
+      found = find_rolegroups(*rolegroups)
+      set_ds_field found
+    end  
+
+    # clears the role of the user in the data store
+    def clear!
+      set_ds_field []
+    end
+    
+    # sets the role to default setting
+    def set_default_role!
+      clear!
+    end                            
+  end
+end

data/lib/trole_groups/strategy.rb

@@ -0,0 +1,30 @@
+# @author Kristian Mandrup
+#
+# Base module for Many roles strategies
+#
+module TroleGroups
+  module Strategy    
+    module BaseMany
+      #
+      # a Many role strategy is included by a role subject (fx a UserAccount class) 
+      # a Many role strategy should always include BaseMany
+      # when BaseMany is included, it ensures that the complete 
+      # Troles API is also included into the role subject
+      #
+      # @note the Trole::Api also includes the Troles::Common::Api
+      #
+      # @param [Class] the role subject class for which to include the Role strategy (fx User Account)
+      #
+      def self.included(base)  
+        base.send :include, TroleGroups::Api
+      end      
+
+      # The storage to use
+      # @return [Troles::Storage] a storage subclass instance matching the needs of the strategy      
+      def group_store
+        @group_store ||= group_storage.new self
+      end
+      
+    end
+  end
+end

data/lib/troles/adapters/active_record/config.rb

@@ -1,9 +1,7 @@
 module Troles::ActiveRecord
   class Config < Troles::Common::Config  
-
-    attr_accessor :role_join_model
     
-    def initialize clazz, options = {}
+    def initialize subject_class, options = {}
       super 
     end
     
@@ -11,7 +9,7 @@ module Troles::ActiveRecord
       case strategy
       when :ref_many
         return configure_join_model if role_join_model
-        has_and_belongs_many clazz, role_model, :key => :accounts         
+        has_and_belongs_many subject_class, object_model, :key => :accounts         
       when :embed_many
         raise "Embed many configuration not yet implemented for ActiveRecord" 
       end
@@ -23,26 +21,51 @@ module Troles::ActiveRecord
     
     protected
 
+    def object_model
+      role_model
+    end
+
+    def role_join_model
+      @join_model_found ||= begin
+        models = [@join_model, join_model_best_guess].select do |class_name|
+          try_class(class_name.to_s.camelize)
+        end.compact
+        # puts "role models found: #{models}"
+        raise "No #{subject_class} to #{object_model} join class defined, define a #{join_model_best_guess} model class or set which class to use, using the :role_join_model option on configuration" if models.empty?
+        models.first.to_s.constantize
+      end
+    end
+
+    def join_model_best_guess
+      "#{subject_class.to_s.pluralize}#{object_model.to_s.pluralize}"
+    end
+
+    def role_join_model= model_class
+      @join_model = model_class and return if model_class.any_kind_of?(Class, String, Symbol)
+      raise "The role model must be a Class, was: #{model_class}"
+    end
+
+
     def join_key
       make_key role_join_model
     end
     
-    def join_model
+    def configure_join_model
       # UserAccount
       # has_many :troles, :class_name => 'Role', :through => :users_roles
-      has_many_for clazz, role_model, :through => join_key 
+      has_many_for subject_class, role_model, :through => join_key 
       # has_many :user_roles, :class_name => 'UserRole'
-      has_many_for clazz, role_join_model, :key => join_key
+      has_many_for subject_class, role_join_model, :key => join_key
 
       # UserRole (custom join class name)
       # belongs_to :user, :class_name => 'UserAccount'      
-      belongs_to_for role_join_model, clazz
+      belongs_to_for role_join_model, subject_class
       # belongs_to :role, :class_name => 'Role'      
       belongs_to_for role_join_model, role_model
 
       # Role
       # has_many :accounts, :class_name => 'User', :through => :user_roles      
-      has_many_for role, clazz, :through => join_key, :key => :accounts
+      has_many_for role, subject_class, :through => join_key, :key => :accounts
 
       # has_many :user_roles, :class_name => 'UserRole'
       has_many_for role, role_join_model, :key => join_key      

data/lib/troles/adapters/mongoid/config.rb

@@ -1,7 +1,7 @@
 module Troles::Mongoid
   class Config < Troles::Common::Config  
     
-    def initialize clazz, options = {}
+    def initialize subject_class, options = {}
       super
     end
 
@@ -9,15 +9,15 @@ module Troles::Mongoid
     def configure_relation
       case strategy
       when :ref_many      
-        has_many_for clazz, :role, :through => join_key 
+        has_many_for subject_class, :role, :through => join_key 
         
-        belongs_to_for join_model, :user
-        belongs_to_for join_model, :role
+        belongs_to_for join_model, subject_class
+        belongs_to_for join_model, object_model
 
-        has_many_for role, :user, :through => join_key 
+        has_many_for role, subject_class, :through => join_key 
         
       when :embed_many
-        embeds_many clazz, :role
+        embeds_many subject_class, object_model
       end
     end
     
@@ -29,7 +29,7 @@ module Troles::Mongoid
         String
       end
       # field :name, :type => String       
-      clazz.send(:field, role_field, type_opts(type)) if type      
+      subject_class.send(:field, role_field, type_opts(type)) if type      
     end     
     
     def type_opts type

data/lib/troles/common/api/core.rb

@@ -45,7 +45,7 @@ module Troles::Common::Api
       #
       # @return [true, false] if role subjects have static roles or not (default: false)
       def static_roles?
-        troles_config.static_roles_for_class?
+        troles_config.static_roles?
       end           
     end
   end

data/lib/troles/common/config.rb

@@ -13,11 +13,11 @@ module Troles::Common
       send :include, "Troles::Common::Config::#{name.to_s.camelize}".constantize
     end
 
-    attr_accessor :clazz, :strategy, :log_on, :generic
+    attr_accessor :subject_class, :strategy, :log_on, :generic, :auto_relations
     attr_writer   :orm
     
-    def initialize clazz, options = {}
-      @clazz = clazz
+    def initialize subject_class, options = {}
+      @subject_class = subject_class
       # set instance var for each pair in options
       apply_options! options
     end
@@ -42,12 +42,58 @@ module Troles::Common
       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 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
+    
+    # protected
+
+    def auto_config_setings
+      @auto_config_setings ||= {}
+    end
+
     def role_field
       @role_field ||= begin
         default_role_field
@@ -68,12 +114,6 @@ module Troles::Common
       @orm || self.class.default_orm
     end
 
-    def apply_options! options = {}
-      options.each_pair do |key, value| 
-        send("#{key}=", value) if self.respond_to?(:"#{key}")
-      end      
-    end
-
     def singularity
       @singularity ||= (strategy =~ /_many$/) ? :many : :one
     end
@@ -82,11 +122,6 @@ module Troles::Common
     #   raise ArgumentError, "Must be :many or :one" if ![:one, :many].include?(value)      
     #   @singularity ||= value
     # end
-
-    def configure! options = {}
-      apply_options! options
-      configure_role_field
-    end
             
     def generic?
       return true if orm.nil?