roles_active_record 0.2.5 → 0.3.1

data/Gemfile

@@ -1,13 +1,21 @@
 source :rubygems
 
-gem "active_record",  ">= 3.0.0.rc"
-gem "active_support", ">= 3.0.0.rc"
-gem "meta_where",     ">= 0.6.0"
+gem "active_record",      ">= 3.0.0"
+gem "active_support",     ">= 3.0.0"
+gem "meta_where",         ">= 0.9"
+gem "arel",               "~> 1.0"    
+gem "meta_where",         ">= 0.9"
+gem "sugar-high",         "~> 0.3.0"
+gem "require_all",        '~> 1.2.0' 
+gem "roles_generic",      '~> 0.2.5'  
+
+gem 'rails3_artifactor',  '~> 0.3.0'
+gem 'logging_assist',     '~> 0.1.5'
 
 group :test do
-  gem "rspec", ">= 2.0.0.beta.19" 
+  gem "rspec",            ">= 2.0.0" 
   gem "yaml"
   gem "logger"
   gem 'database_cleaner'
-  gem "generator_spec", '>= 0.4.5'
+  gem "generator_spec",   '>= 0.7.0'
 end

data/Rakefile

@@ -7,21 +7,20 @@ begin
     gem.email = "kmandrup@gmail.com"
     gem.homepage = "http://github.com/kristianmandrup/roles_for_dm"
     gem.authors = ["Kristian Mandrup"]
-    gem.add_development_dependency "rspec",             '>= 2.0.0.rc'
-    gem.add_development_dependency 'database_cleaner',  '~> 0.5.2'
-    gem.add_development_dependency "generator-spec",    '~> 0.6.5'
-
-    gem.add_dependency "activerecord",      "~> 3.0.0"
-    gem.add_dependency "activesupport",     "~> 3.0.0"
-    gem.add_dependency "arel",              "~> 1.0.0"    
-    gem.add_dependency "meta_where",        "~> 0.9.3"
-    gem.add_dependency "sugar-high",        "~> 0.2.11"
-    gem.add_dependency "require_all",       '~> 1.2.0' 
-    gem.add_dependency "roles_generic",     '~> 0.2.5'
-    gem.add_dependency 'rails3_artifactor', '>= 0.2.6'
-    gem.add_dependency 'logging_assist',    '>= 0.1.5'
-    gem.add_dependency 'migration_assist',  '>= 0.1.5'
+    gem.add_development_dependency "rspec",             '>= 2.0'
+    gem.add_development_dependency 'database_cleaner',  '>= 0.5'
+    gem.add_development_dependency "generator-spec",    '>= 0.7.0'
 
+    gem.add_dependency "activerecord",    "~> 3.0"
+    gem.add_dependency "activesupport",   "~> 3.0"
+    gem.add_dependency "arel",            "~> 1.0"    
+    gem.add_dependency "meta_where",      ">= 0.9"
+    gem.add_dependency "sugar-high",      "~> 0.3.0"
+    gem.add_dependency "require_all",     '~> 1.2.0' 
+    gem.add_dependency "roles_generic",   '>= 0.3.0'  
+    
+    gem.add_dependency 'rails3_artifactor', '~> 0.3.1'
+    gem.add_dependency 'logging_assist',    '~> 0.1.6'
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.3.1

data/lib/roles_active_record/role.rb

@@ -2,9 +2,12 @@ module Roles::Base
   def valid_roles_are(*role_list)
     strategy_class.valid_roles = role_list.to_symbols
     if role_class_name
+      "Create Roles: #{role_list}"
       role_list.each do |name|
         role_class_name.create(:name => name.to_s)        
       end
+    else
+      "Using Inline roles"
     end
   end
 end

data/lib/roles_active_record/strategy/multi/many_roles.rb

@@ -1,13 +1,15 @@
-class Role < ActiveRecord::Base  
-  scope :named, lambda{|role_names| where(:name.in => role_names.flatten)}  
+require 'roles_active_record/strategy/multi'
+
+class Role < ActiveRecord::Base
+  scope :named, lambda{|role_names| where(:name.in => role_names.flatten)}
   has_many :users, :through => :user_roles
-  has_many :user_roles      
-end  
+  has_many :user_roles
+end
 
-class UserRole < ActiveRecord::Base  
+class UserRole < ActiveRecord::Base
   belongs_to :user
   belongs_to :role
-end  
+end
 
 module RoleStrategy::ActiveRecord
   module ManyRoles
@@ -17,58 +19,53 @@ module RoleStrategy::ActiveRecord
 
     def self.included base
       base.extend Roles::Generic::Role::ClassMethods
-      base.extend ClassMethods            
+      base.extend ClassMethods
       base.has_many :many_roles, :through => :user_roles, :source => :role
-      base.has_many :user_roles    
+      base.has_many :user_roles
     end
 
-    module ClassMethods    
-      def in_role(role_name)                          
-        in_roles(role_name)
+    module ClassMethods
+      def in_role(role_name)
+        in_any_role(role_name)
       end
 
-      def in_roles(*role_names)                          
-        joins(:many_roles) & Role.named(role_names)
+      def in_any_role(*role_names)
+        joins(:many_roles) & Role.named(role_names.to_strings)
       end
     end
-    
+
     module Implementation
-      def role_attribute
-        strategy_class.roles_attribute_name
-      end 
-      
-      # assign roles
-      def roles=(*_roles)  
-        _roles = get_roles(_roles)
-        return nil if _roles.none?
+      include Roles::ActiveRecord::Strategy::Multi
 
-        role_relations = role_class.find_roles(_roles) 
-        self.send("#{role_attribute}=", role_relations)
-        save
+      # assign multiple roles
+      def roles=(*role_names)
+        puts "Assign roles #{role_names}"        
+        role_names = role_names.flat_uniq
+        role_names = extract_roles(role_names)
+        return nil if role_names.empty?
+        puts "role names #{role_names}"
+        valids = role_class.find_roles(role_names).to_a
+        puts "valids: #{valids}"
+        vrs = select_valid_roles role_names
+        puts "Set valid roles #{vrs}"
+        set_roles(vrs)
       end
 
-      def add_roles(*_roles)  
-        _roles = get_roles(_roles)
-        return nil if _roles.none?                
 
-        role_relations = role_class.find_roles(_roles)
-        puts "role_relations: #{role_relations.inspect}"
-        self.send(role_attribute) << role_relations
-        save
+      def new_roles *role_names
+        role_class.find_roles(extract_roles role_names)
       end
 
-      # query assigned roles
-      def roles
-        self.send(role_attribute)
+      def present_roles roles_names
+        roles_names.to_a.map{|role| role.name.to_s.to_sym}
       end
 
-      def roles_list     
-        [roles].flatten.map{|r| r.name }.compact.to_symbols
+      def set_empty_roles
+        self.send("#{role_attribute}=", [])
       end
-    end 
-    
+    end
+
     extend Roles::Generic::User::Configuration
-    configure :type => :role_class    
+    configure :type => :role_class
   end
 end
-

data/lib/roles_active_record/strategy/multi/roles_mask.rb

@@ -1,3 +1,5 @@
+require 'roles_active_record/strategy/multi'
+
 module RoleStrategy::ActiveRecord
   module RolesMask
     def self.default_role_attribute
@@ -20,7 +22,7 @@ module RoleStrategy::ActiveRecord
         end
       end    
 
-      def in_roles(*roles)
+      def in_any_role(*roles)
         all.select do |user| 
           roles.flatten.any? do |role|
             mask = calc_index(role.to_s)
@@ -34,7 +36,9 @@ module RoleStrategy::ActiveRecord
       end 
     end
 
-    module Implementation 
+    module Implementation
+      include Roles::ActiveRecord::Strategy::Multi      
+
       class Roles < ::Set # :nodoc:
         attr_reader :model_instance
 
@@ -49,32 +53,27 @@ module RoleStrategy::ActiveRecord
         end
       end
 
-      def role_attribute
-        strategy_class.roles_attribute_name
-      end 
+      protected
+
+      def calc_index(r)
+        2**strategy_class.valid_roles.index(r)
+      end
 
-      # assign roles
-      def roles=(*roles)
-        the_roles = (roles.flatten.map { |r| r.to_sym } & strategy_class.valid_roles)
-        value = the_roles.map{ |r| calc_index(r) }.inject{ |sum, bitvalue| sum + bitvalue }
-        puts "value: #{value}"
-        self.send "#{role_attribute}=", value
+      def get_roles
+        strategy_class::Roles.new(self, strategy_class.valid_roles.reject { |r| ((get_role || 0) & calc_index(r)).zero? })        
       end
-      alias_method :role=, :roles=
       
-      # query assigned roles
-      def roles
-        strategy_class::Roles.new(self, strategy_class.valid_roles.reject { |r| ((self.send(role_attribute) || 0) & calc_index(r)).zero? })
+      def new_roles *role_names
+        role_names = role_names.flatten.map{ |r| r.to_sym } & strategy_class.valid_roles
+        role_names.map { |r| calc_index(r) }.inject { |sum, bitvalue| sum + bitvalue }
       end
 
-      def roles_list
-        roles.to_a
-      end        
-
-      protected
-
-      def calc_index(r)
-        2**strategy_class.valid_roles.index(r)
+      def set_empty_roles
+        self.send("#{role_attribute}=", 0)
+      end
+      
+      def present_roles *role_names
+        role_names.to_a.to_symbols
       end
     end    
     

data/lib/roles_active_record/strategy/multi.rb

@@ -0,0 +1,54 @@
+require 'roles_active_record/strategy/shared'
+
+module Roles::ActiveRecord
+  module Strategy
+    module Multi     
+      # assign multiple roles
+      def roles=(*role_names)
+        extracted_roles = extract_roles(role_names)
+        return nil if extracted_roles.empty?
+        set_roles(select_valid_roles extracted_roles)
+      end      
+      
+      def add_roles *roles
+        new_roles = select_valid_roles(roles)
+        if !new_roles.empty?
+          self.roles = self.roles + new_roles
+        end
+      end      
+      
+      # should remove the current single role (set = nil) 
+      # only if it is contained in the list of roles to be removed
+      def remove_roles *role_names
+        role_names = role_names.flat_uniq
+        set_empty_roles and return if roles_diff(role_names).empty?
+        roles_to_remove = select_valid_roles(role_names)
+        set_roles roles_diff(role_names)
+        true
+      end
+
+      # query assigned roles
+      def roles
+        get_roles.map do |role|
+          role.respond_to?(:sym) ? role.to_sym : role
+        end
+      end
+
+      def roles_list
+        my_roles = [roles].flat_uniq
+        return [] if my_roles.empty?
+        has_role_class? ? my_roles.map{|r| r.name.to_sym } : my_roles          
+      end
+      
+      protected
+      
+      def set_roles *roles                      
+        self.send("#{role_attribute}=", new_roles(roles))
+      end
+
+      def get_roles
+        self.send(role_attribute)
+      end      
+    end
+  end
+end

data/lib/roles_active_record/strategy/shared.rb

@@ -0,0 +1,26 @@
+module Roles::ActiveRecord
+  module Strategy
+    module Shared
+      def set_role role
+        vr = new_role(role)
+        # self.send("#{role_attribute}=", vr)
+        update_attributes(role_attribute => vr)
+      end
+      alias_method :set_roles, :set_role
+
+      def get_role
+        r = self.send(role_attribute)
+        # respond_to?(:present_role) ? present_role(r) : r
+      end
+
+      def get_roles
+        r = self.send(role_attribute)
+      end
+
+      def select_valid_roles *roles
+        roles.flat_uniq.select{|role| valid_role? role }
+        has_role_class? ? role_class.find_roles(roles).to_a.flat_uniq : roles.flat_uniq
+      end           
+    end
+  end
+end

data/lib/roles_active_record/strategy/single/admin_flag.rb

@@ -1,3 +1,5 @@
+require 'roles_active_record/strategy/single'
+
 module RoleStrategy::ActiveRecord
   module AdminFlag    
     def self.default_role_attribute
@@ -24,26 +26,25 @@ module RoleStrategy::ActiveRecord
     end
 
     module Implementation
-      def role_attribute
-        strategy_class.roles_attribute_name
-      end
-          
-      # assign roles
-      def roles=(*new_roles)                                 
-        first_role = new_roles.flatten.first
-        if valid_role?(first_role)
-          self.send("#{role_attribute}=", new_roles.flatten.first.admin?) 
-        else
-          raise ArgumentError, "The role #{first_role} is not a valid role"
-        end
-      end
+      include Roles::ActiveRecord::Strategy::Single
 
-      # query assigned roles
-      def roles
-        role = self.send(role_attribute) ? strategy_class.admin_role_key : strategy_class.default_role_key
-        [role]
+      def new_role role
+        role = role.kind_of?(Array) ? role.flatten.first : role
+        role.admin?
       end
-      alias_method :roles_list, :roles
+      
+      def get_role
+        self.send(role_attribute) ? strategy_class.admin_role_key : strategy_class.default_role_key
+      end 
+      
+      def present_roles *roles
+        roles = roles.flat_uniq
+        roles.map{|role| role ? :admin : :guest}
+      end   
+      
+      def set_empty_role
+        self.send("#{role_attribute}=", false)
+      end      
 
     end # Implementation
     

data/lib/roles_active_record/strategy/single/one_role.rb

@@ -1,7 +1,9 @@
-class Role < ActiveRecord::Base  
-  scope :named, lambda{|role_names| where(:name.in => role_names.flatten)}  
-  belongs_to :user
-end  
+require 'roles_active_record/strategy/single'
+
+class Role < ActiveRecord::Base
+  scope :named, lambda{|role_names| where(:name.in => role_names.flatten)}
+  has_many :users
+end
 
 module RoleStrategy::ActiveRecord
   module OneRole
@@ -11,40 +13,47 @@ module RoleStrategy::ActiveRecord
 
     def self.included base
       base.extend Roles::Generic::Role::ClassMethods
-      base.extend ClassMethods            
-      base.has_one :one_role, :foreign_key => :role_id, :class_name => 'Role'      
+      base.extend ClassMethods
+      base.belongs_to :one_role, :foreign_key => :role_id, :class_name => 'Role'
     end
 
-    module ClassMethods    
-      def in_role(role_name)                          
-        in_roles(role_name)
+    module ClassMethods
+      def in_role(role_name)
+        in_any_role(role_name)
       end
 
-      def in_roles(*role_names)                          
+      def in_any_role(*role_names)
         joins(:one_role) & Role.named(role_names)
       end
     end
 
-    module Implementation      
-      # assign roles
-      def roles=(*_roles)      
-        _roles = get_roles(_roles)
-        return nil if _roles.none?                
+    module Implementation
+      include Roles::ActiveRecord::Strategy::Single
+
+      def new_role role
+        role_class.find_role(extract_role role)
+      end
+
+      def new_roles *roles
+        new_role roles.flatten.first
+      end
+
+      def remove_roles *role_names
+        roles = role_names.flat_uniq
+        set_empty_role if roles_diff(roles).empty?
+        true
+      end 
 
-        role_relation = role_class.find_role(_roles.first) 
-        self.send("#{role_attribute}=", role_relation)
+      def present_roles *roles
+        roles.map{|role| extract_role role}
       end
-      alias_method :role=, :roles=
-      
-      # query assigned roles
-      def roles
-        [self.send(role_attribute).name.to_sym]
+
+      def set_empty_role
+        self.send("#{role_attribute}=", nil)
       end
-      alias_method :roles_list, :roles
-      
     end
 
     extend Roles::Generic::User::Configuration
-    configure :num => :single, :type => :role_class    
-  end  
+    configure :num => :single, :type => :role_class
+  end
 end

data/lib/roles_active_record/strategy/single/role_string.rb

@@ -1,3 +1,5 @@
+require 'roles_active_record/strategy/single'
+
 module RoleStrategy::ActiveRecord
   module RoleString    
     def self.default_role_attribute
@@ -15,32 +17,35 @@ module RoleStrategy::ActiveRecord
 
       def in_role(role_name) 
         where(role_attribute => role_name)
-      end
+      end        
+      
+      def in_any_role(*role_names)
+        where(:role_attribute.in => role_names)
+      end      
     end
-
     
     module Implementation 
-      def role_attribute
-        strategy_class.roles_attribute_name
-      end 
-                  
-      # assign roles
-      def roles=(*roles)
-        self.role = roles.select_labels.first.to_s
-      end 
+      include Roles::ActiveRecord::Strategy::Single
+
+      def new_role role
+        role = role.kind_of?(Array) ? role.first : role
+        role.to_s
+      end
+
+      def new_roles *roles
+        new_role roles.flatten.first
+      end
       
-      def role= role_name
-        if role_name.kind_of_label? && valid_role?(role_name)
-          self.send("#{role_attribute}=", role_name.to_s) 
-        end        
+      def present_role role
+        return role if role.kind_of? Array
+        role.split(',').map(&:to_sym)
       end
 
-      # query assigned roles
-      def roles
-        role = self.send(role_attribute)
-        [role.to_sym]
+      def set_empty_role
+        self.send("#{role_attribute}=", "")
       end
-      alias_method :roles_list, :roles
+
+      alias_method :present_roles, :present_role
     end
 
     extend Roles::Generic::User::Configuration

data/lib/roles_active_record/strategy/single.rb

@@ -0,0 +1,34 @@
+require 'roles_active_record/strategy/shared'
+
+class Symbol
+  def admin?
+    self == :admin
+  end
+end
+
+module Roles::ActiveRecord
+  module Strategy
+    module Single
+      include Shared            
+      # assigns first valid role from list of roles
+      def add_roles *role_names
+        new_roles = select_valid_roles(role_names) 
+        new_role = new_roles.first if !new_roles.empty?
+        set_role new_role
+      end
+
+      # should remove the current single role (set = nil) 
+      # only if it is contained in the list of roles to be removed
+      def remove_roles *role_names
+        roles = role_names.flat_uniq
+        set_empty_role if roles_diff(roles).empty?
+        true
+      end 
+      
+      def roles_list
+        raise 'the method #roles should be present' if !respond_to? :roles
+        present_roles(roles)
+      end            
+    end
+  end
+end