troles 0.5.0 → 0.5.1

data/lib/troles/common/config/schema.rb

@@ -1,16 +1,17 @@
 module Troles::Common
   class Config
     module Schema
-      attr_accessor :join_model
-
-      def configure_role_field
+      autoload :Helpers,      'troles/common/config/schema/helpers'
+      autoload :RoleHelpers,  'troles/common/config/schema/role_helpers'
+      
+      def configure_models
         configure_generic
-        configure_field
-        configure_relation
+        configure_field if auto_config?(:fields)
+        configure_relation if auto_config?(:relations)
       end         
 
       def configure_generic                    
-        clazz.send(:attr_accessor, role_field)  if generic? || orm == :generic # create troles accessor      
+        subject_class.send(:attr_accessor, role_field)  if generic? || orm == :generic # create troles accessor      
       end
 
       # Adapter should customize this as needed 
@@ -21,18 +22,6 @@ module Troles::Common
       def configure_relation
       end
 
-      def join_model
-        @join_model ||= begin
-          return UsersRoles if defined? UsersRoles
-          raise "Join model not defined"
-        end
-      end
-
-      def join_model= model_class
-        @join_model = model_class and return if model_class.kind_of?(Class)
-        raise "The role model must be a Class, was: #{model_class}"
-      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
@@ -46,17 +35,21 @@ module Troles::Common
       # @return [Class] the model class (defaults to Role)
       def role_model
         @role_model_found ||= begin
-          models = [@role_model, 'Role'].select do |class_name|
-            try_class(class_name.to_s)
+          models = [@role_model, role_class_name].select do |class_name|
+            try_class(class_name.to_s.camelize)
           end.compact
           # puts "role models found: #{models}"
-          raise "No Role class defined, define Role one or set using #role_model method on config" if models.empty?
+          raise "No #{role_class_name} class defined, define a #{role_class_name} class or set which class to use, using the :role_model option on configuration" if models.empty?
           models.first.to_s.constantize
         end
       end
 
       protected
 
+      def role_class_name
+        'Role'
+      end
+
       def try_class clazz
         begin
           clazz = clazz.constantize if clazz.kind_of?(String)
@@ -66,7 +59,8 @@ module Troles::Common
         end
       end
                      
-      include SchemaHelpers
- end
+      include Helpers
+      include RoleHelpers      
+    end
   end
 end

data/lib/troles/common/config/schema/helpers.rb

@@ -0,0 +1,77 @@
+module Troles::Common
+  class Config
+    module Schema
+      module Helpers
+        def valid_field_name? name
+          return false if !name || name.empty?
+          raise ArgumentException, "Role field must not be named role or roles as these names are reserved by troles!" if [:role, :roles].include? name.to_sym
+          true
+        end
+
+        def boolean? value
+          [true, false].include? value
+        end
+
+        # TODO: Needs extraction into helper module!
+
+        def belongs_to_for from, to, options = {}
+          make_relationship :belongs_to, from, to, options
+        end
+
+        def has_many_for from, to, options = {}
+          make_relationship :has_many, from, to, options
+        end
+
+        def has_one_for from, to, options = {}
+          make_relationship :has_one, from, to, options
+        end
+
+        # To setup sth like this:
+        #
+        # class UserAccount < ActiveRecord::Base    
+        #   has_and_belongs_to_many :troles, :class_name => 'Role'
+        # end
+        # 
+        # class Role < ActiveRecord::Base    
+        #   has_and_belongs_to_many :user_accounts, :class_name => 'User'
+        # end
+        def has_and_belongs_many from, to, options = {}
+          make_relationship :has_and_belongs_to_many, from, to, :key => role_field
+          make_relationship :has_and_belongs_to_many, to, from, options
+        end
+
+        def get_model_type class_name
+          return :user if class_name == subject_class
+          return :role if class_name == object_model
+          raise "Not a known model: #{class_name}"
+        end
+
+        # options: 
+        # - :opts, extras options, fx to set the :through relationship
+        # - :key (usually to enforce use of role_field as key name)      
+        def make_relationship type, from, to, options = {}
+          # puts "type: #{type}, #{from}, #{to}"
+          from_type = get_model_type from
+          to_type = get_model_type to
+
+          model_key = options[:key] ? options[:key] : send("#{from_type}_key")
+
+          class_name = send "#{to_type}_class_name"
+
+          options = {:class_name => class_name}
+          options.merge!(options[:opts]) if options[:opts]
+          puts "#{from}.#{type} :#{model_key}, #{options.inspect}" if log_on?
+          from.send(type, model_key, options)
+        end
+            
+        def object_key
+          make_key object_class_name
+        end
+
+        def make_key name
+          name.to_s.gsub(/::/, '__').underscore.pluralize      
+        end
+      end
+    end
+  end
+end

data/lib/troles/common/config/schema/role_helpers.rb

@@ -0,0 +1,27 @@
+module Troles::Common
+  class Config
+    module Schema
+      module RoleHelpers
+        def subject_class_name
+          subject_class.to_s
+        end
+
+        def subject_key
+          make_key subject_class_name
+        end
+
+        def join_class_name
+          join_model.to_s
+        end
+
+        def join_key
+          make_key join_class_name
+        end
+
+        def object_class_name
+          object_model.to_s
+        end
+      end
+    end
+  end
+end

data/lib/troles/common/config/static_roles.rb

@@ -1,13 +1,13 @@
 module Troles::Common
   class Config
     module StaticRoles    
-      def static_roles_for_class= value
+      def static_roles= value
         raise ArgumentError, "Must be a boolean" if !boolean?(value)
-        @static_roles_for_class = value      
+        @static_roles = value      
       end
 
-      def static_roles_for_class?
-        @static_roles_for_class || false
+      def static_roles?
+        @static_roles || false
       end
     end
   end

data/lib/troles/common/macros.rb

@@ -9,8 +9,6 @@
 #     troles_strategy :bit_many
 #
 
-puts "Troles macros enabled!"
-
 module Troles  
   module Macros
     autoload :Configuration, 'troles/common/macros/configuration'
@@ -19,12 +17,14 @@ module Troles
       configuration = Configuration.new self, strategy, options
 
       configuration.load_adapter
-      # puts "strategy module: #{configuration.strategy_module}"
+      puts "strategy module: #{configuration.strategy_module}"
+      puts configuration.strategy_module.methods.grep /store/ 
+      
       send :include, configuration.strategy_module
 
       configuration.define_hooks
       configuration.apply_strategy_options!
-      
+
       if strategy == :bit_one 
         troles_config.valid_roles = [:user, :admin] # default binary roles 
       end

data/lib/troles/common/macros/configuration.rb

@@ -6,10 +6,10 @@ module Troles
       autoload :StrategyLoader, 'troles/common/macros/configuration/strategy_loader'
       autoload :StorageLoader,  'troles/common/macros/configuration/storage_loader'      
       
-      attr_reader :strategy, :singularity, :orm, :auto_load, :options, :role_subject_class
+      attr_reader :strategy, :singularity, :orm, :auto_load, :options, :subject_class
       
-      def initialize role_subject_class, strategy, options = {}
-        @role_subject_class = role_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?
@@ -33,23 +33,23 @@ module Troles
       end
   
       def apply_strategy_options!
-        role_subject_class.troles_config.apply_options! options
+        subject_class.troles_config.apply_options! options
 
-        # StrategyOptions.new(clazz)
+        # StrategyOptions.new(subject_class)
         # extract_macros(options).each{|m| apply_macro m}
       end      
 
       def define_hooks
         storage_class = storage_loader.storage_class
-        role_subject_class.send :define_method, :storage do 
+        subject_class.send :define_method, :storage do 
           @storage ||= storage_class
         end
         
         config_class = config_loader.config_class
         puts "config_class: #{config_class}" if Troles::Config.log_on
-        role_subject_class.singleton_class.class_eval %{
+        subject_class.singleton_class.class_eval %{
           def troles_config
-            @troles_config ||= #{config_class}.new #{role_subject_class}, #{options.inspect}
+            @troles_config ||= #{config_class}.new #{subject_class}, #{options.inspect}
           end
         }
       end

data/lib/troles/common/macros/strategy_options.rb

@@ -1,17 +1,17 @@
 module Troles  
   module Macros    
     class StrategyOptions
-      attr_reader :clazz
+      attr_reader :subject_class
   
-      def initialize clazz
-        @clazz = clazz
+      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 
-          clazz.send :include,  "Troles::Macros::#{strategy_name.to_s.camelize}".constantize
+          subject_class.send :include,  "Troles::Macros::#{strategy_name.to_s.camelize}".constantize
         rescue
         end
       end

data/lib/troles/common/storage.rb

@@ -28,6 +28,7 @@ module Troles::Common
     # 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
       role_subject.send(:"#{ds_field_name}=", value)
       persist_role_changes!
     end

data/lib/troles/config.rb

@@ -1,10 +1,10 @@
 module Troles
   class Config < Troles::Common::Config    
-    def initialize clazz, options = {}
+    def initialize subject_class, options = {}
       super
     end
 
-    def configure_role_field
+    def configure_models
       super
     end       
         

data/lib/troles/storage/ref_many.rb

@@ -26,9 +26,8 @@ module Troles::Storage
     
     # saves the role for the user in the data store
     def set_roles *roles
-      # finds and sets references to existing Role instances from symbols        
-      found_roles = find_roles(*roles)
-      set_ds_field found_roles
+      # finds and sets references to existing Role instances from symbols
+      set_ds_field find_roles(*roles)
     end  
 
     # clears the role of the user in the data store

data/spec/active_record/models/ref_many.rb

@@ -6,5 +6,8 @@ end
 
 class Role < ActiveRecord::Base    
   # has_and_belongs_to_many :accounts, :class_name => 'User'
+end 
+
+class MyUsersRoles < ActiveRecord::Base
 end
 

data/spec/active_record/strategies/many/ref_many_spec.rb

@@ -12,7 +12,8 @@ end
 
 User.troles_strategy :ref_many do |c|
   c.valid_roles = [:user, :admin, :blogger, :editor]
-end.configure!
+  c.auto_config[:relations] = false
+end.configure! :role_join_model => 'MyUsersRoles'
 
 module UserSetup
   def find_role name

data/spec/generic/models/role.rb

@@ -31,7 +31,8 @@ class Role
     end
 
     def where options = {}
-      Role.roles.select {|r| r.name == options[:name].to_sym }
+      names = [options[:name]].flatten
+      Role.roles.select {|r| names.include?(r.name.to_sym) }
     end  
   end
 end

data/spec/trole_groups/api/core_api_spec.rb

@@ -0,0 +1,14 @@
+shared_examples_for "TroleGroup Core API" do
+  # Core API
+  specify             { lambda { user.rolegroup_field }.should raise_error } # no, role_field is a class method    
+  specify             { User.rolegroup_field.should_not be_nil } # yes, role_field is a class method    
+
+  subject { user }
+    its(:rolegroup_list)     { should include(:blog_admin) }
+    its(:rolegroups)         { should be_a TroleGroups::Operations }
+
+  # specify             { user.static_role_groups?.should be_false }
+  # specify             { User.static_role_groups?.should be_false }  
+  
+  # TODO: Add examples with other users?
+end

data/spec/trole_groups/api/read_api_spec.rb

@@ -0,0 +1,36 @@
+shared_examples_for "TroleGroup Read API" do
+
+  specify { user.has_rolegroup?(:blog_admin).should be_true }
+  
+  it "only be in role groups" do
+    user.only_in_rolegroup?(:blog_admin).should be_true
+    user.add_rolegroups :super_admin    
+    user.only_in_rolegroup?(:blog_admin).should be_false
+    user.remove_rolegroups :super_admin
+  end
+        
+  specify { user.has_rolegroups?(:blog_admin).should be_true }
+  
+  it "should be in 2 role groups" do
+    user.add_rolegroups :super_admin      
+    user.has_rolegroups?(:blog_admin, :super_admin).should be_true
+    user.has_any_rolegroup?(:super_admin).should be_true    
+
+    # adding single roles and role groups together produces union of roles from all :)
+    user.add_roles :editor    
+    user.role_list.should include(:editor, :blogger, :blog_editor, :admin, :blog_admin)
+  end
+        
+  specify { user.has_any_rolegroup?(:blog_admin, :admin).should be_true }
+  specify { user.has_any_rolegroup?(:blip).should be_false }       
+
+  subject { user }
+    its(:rolegroup_list) { should include(:blog_admin) }
+
+  it 'should cache the rolegroup list' do
+    user.rolegroup_list.should include(:blog_admin)
+    # calling rolegroup_list multiple times should NOT invalidate the cache :)
+    expect { user.rolegroup_list }.to_not change{ user.rolegroup_list_value }
+    user.rolegroup_list.should include(:blog_admin)
+  end
+end

data/spec/trole_groups/api/write_api_spec.rb

@@ -0,0 +1,19 @@
+shared_examples_for "TroleGroup Write API" do
+
+  describe '#clear_rolegroups!' do
+    it "should clear rolegroups and invalidate rolegroups cache" do
+      user.set_rolegroups :admin
+      user.clear_rolegroups!
+      expect { user.rolegroup_list }.to change{user.rolegroup_list_value }
+      user.rolegroup_list.should be_empty      
+    end
+
+    it "successive clear rolegroups should not invalidate rolegroups cache" do
+      user.set_rolegroups :admin
+      user.clear_rolegroups!
+      expect { user.rolegroup_list }.to change{user.rolegroup_list_value }
+      user.clear_rolegroups!
+      expect { user.rolegroup_list }.to_not change{user.rolegroup_list_value }
+    end
+  end
+end

data/spec/trole_groups/api_spec.rb

@@ -0,0 +1,27 @@
+# See http://blog.davidchelimsky.net/2010/11/07/specifying-mixins-with-shared-example-groups-in-rspec-2/
+# And: http://relishapp.com/rspec/rspec-core/v/2-6/dir/example-groups/shared-examples
+# Also: http://stackoverflow.com/questions/6152359/dynamically-generating-shared-examples-in-rspec-2
+
+require_all File.dirname(__FILE__) + '/api'
+
+def define_users
+  let(:no_roles_user) { create_no_roles_user  }
+  let(:user)          { create_user  }
+  let(:admin_user)    { create_admin_user  }
+end  
+
+shared_examples_for "TroleGroup API" do
+  include UserSetup 
+     
+  it_behaves_like "TroleGroup Core API" do
+    define_users
+  end  
+
+  it_behaves_like "TroleGroup Read API" do
+    define_users
+  end  
+
+  it_behaves_like "TroleGroup Write API" do
+    define_users
+  end  
+end