roles_mongoid 0.2.4 → 0.3.1

data/Rakefile

@@ -7,14 +7,18 @@ begin
     gem.email = "kmandrup@gmail.com"
     gem.homepage = "http://github.com/kristianmandrup/roles_mongoid"
     gem.authors = ["Kristian Mandrup"]
-    gem.add_development_dependency "rspec", '~> 2.0.0.beta.22'
+    gem.add_development_dependency "rspec", '>= 2.1'
+
+    gem.add_dependency "mongoid",           '>= 2.0.0.beta.19'
+    gem.add_dependency 'bson',              '>= 1.1.1'
+
+    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.add_dependency "mongoid",           '~> 2.0.0.beta.18'
-    gem.add_dependency 'bson',              '~> 1.0.7'
-    gem.add_dependency "activesupport",     '~> 3.0.0'
-    gem.add_dependency "require_all",       '~> 1.2.0' 
-    gem.add_dependency "sugar-high",        '~> 0.2.11'        
-    gem.add_dependency "roles_generic",     '~> 0.2.7'        
 
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.1

data/lib/roles_mongoid/base.rb

@@ -16,9 +16,11 @@ module Roles
       
       MAP = {
         :admin_flag   => "field :admin_flag, :type => Boolean",
-        :many_roles   => "references_many :many_roles, :stored_as => :array, :class_name => 'Role', :default => []",
-        :one_role     => "references_one :one_role, :class_name => 'Role'",
-        :roles_mask   => "field :roles_mask, :type => Integer, :default => 1",
+        
+        :many_roles   => "references_many :many_roles, :stored_as => :array, :class_name => 'Role'",
+        :one_role     => "referenced_in :one_role, :class_name => 'Role'",
+
+        :roles_mask   => "field :roles_mask, :type => Integer, :default => 0",
         :role_string  => "field :role_string, :type => String",
         :role_strings => "field :role_strings, :type => Array",
         :roles_string => "field :roles_string, :type => String"
@@ -28,7 +30,7 @@ module Roles
         if options == :default && MAP[name]
           instance_eval MAP[name] 
         end
-        role_strategy name, options
+        set_role_strategy name, options
       end    
     end
   end

data/lib/roles_mongoid/role.rb

@@ -12,7 +12,9 @@ end
 class Role
   include Mongoid::Document
   field :name, :type => String
-  referenced_in :user
+  # references_many :users
+
+  # references_many :users, :class_name => 'User', :stored_as => :array  
 
   class << self
     def find_roles(*role_names)

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

@@ -1,3 +1,5 @@
+require 'roles_mongoid/strategy/multi'
+
 module RoleStrategy::Mongoid
   module ManyRoles
     def self.default_role_attribute
@@ -9,59 +11,73 @@ module RoleStrategy::Mongoid
       base.extend ClassMethods
     end
 
-    module ClassMethods  
+    module ClassMethods
       def role_attribute
         "#{strategy_class.roles_attribute_name.to_s.singularize}_ids".to_sym
-      end       
-        
-      def in_role(role_name)  
-        in_roles(role_name)
       end
 
-      def in_roles(*role_names)
-        begin           
+      def in_role(role_name)
+        in_any_role(role_name)
+      end
+
+      def in_any_role(*role_names)
+        begin
           role_ids = Role.where(:name.in => role_names.to_strings).to_a.map(&:_id)
-          criteria.in(role_attribute => role_ids).to_a      
+          where(:"#{role_attribute}".in => role_ids).to_a
         rescue
           return []
         end
-      end  
+      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::Mongoid::Strategy::Multi
+
+      def has_roles?(*roles_names)
+        compare_roles = extract_roles(roles_names.flat_uniq)
+        (roles_list & compare_roles).not.empty?      
+      end
+
+      def get_roles
+        self.send(role_attribute)
+      end      
+
+      def roles
+        get_roles.to_a.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
         
-        role_relations = role_class.find_roles(_roles) 
-        self.send("#{role_attribute}=", role_relations)
-        save
+      # assign multiple roles
+      def roles=(*role_names)
+        role_names = role_names.flat_uniq
+        role_names = extract_roles(role_names)
+        return nil if role_names.empty?
+        valids = role_class.find_roles(role_names).to_a
+        vrs = select_valid_roles role_names
+        set_roles(vrs)
       end
 
-      def add_roles(*roles)  
-        raise "Role class #{role_class} does not have a #find_role(role) method" if !role_class.respond_to? :find_role
-        role_relations = role_class.find_roles(*roles)
-        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_mongoid/strategy/multi/role_strings.rb

@@ -1,3 +1,5 @@
+require 'roles_mongoid/strategy/multi'
+
 module RoleStrategy::Mongoid
   module RoleStrings    
     def self.default_role_attribute
@@ -14,10 +16,10 @@ module RoleStrategy::Mongoid
       end 
 
       def in_role(role_name)  
-        in_roles(role_name)
+        in_any_role(role_name)
       end
 
-      def in_roles(*role_names)
+      def in_any_role(*role_names)
         begin
           where(role_attribute.in => role_names).to_a      
         rescue
@@ -27,30 +29,49 @@ module RoleStrategy::Mongoid
     end
     
     module Implementation 
-      # assign roles
-      def roles=(*new_roles)
-        new_roles = new_roles.flatten.map{|r| r.to_s if valid_role?(r)}.compact
-        if new_roles && new_roles.not.empty?
-          self.send("#{role_attribute}=", new_roles.compact.uniq) 
-        end
-      end
-      alias_method :role=, :roles=
+      include Roles::Mongoid::Strategy::Multi
+      
+      def new_roles *roles
+        ::Set.new select_valid_roles(roles)
+      end      
 
-      def add_roles(*roles_to_add)
-        roles_to_add = roles_to_add.flatten.map{|r| r.to_s if valid_role?(r)}.compact
-        if new_roles && new_roles.not.empty?
-          self.send(role_attribute) << new_roles.compact.uniq
-        end
-      end
+      def select_valid_roles *roles
+        roles.flat_uniq.select{|role| valid_role? role }.map(&:to_sym)
+      end                 
+      
+      def set_empty_roles
+        self.send("#{role_attribute}=", [])
+      end   
 
-      # query assigned roles
-      def roles
-        self.send(role_attribute).map{|r| r.to_sym}
+      def present_roles roles_names
+        roles_names.to_a
       end
       
-      def roles_list     
-        [roles].flatten
-      end      
+      # # assign roles
+      # def roles=(*new_roles)
+      #   new_roles = new_roles.flatten.map{|r| r.to_s if valid_role?(r)}.compact
+      #   if new_roles && new_roles.not.empty?
+      #     self.send("#{role_attribute}=", new_roles.compact.uniq) 
+      #   end
+      # end
+      # alias_method :role=, :roles=
+      # 
+      # def add_roles(*roles_to_add)
+      #   new_roles = roles_to_add.flatten.map{|r| r.to_s if valid_role?(r)}.compact
+      #   if new_roles && new_roles.not.empty?
+      #     self.send(role_attribute) << new_roles.compact.uniq
+      #   end
+      # end
+      # alias_method :add_role
+      # 
+      # # query assigned roles
+      # def roles
+      #   self.send(role_attribute).map{|r| r.to_sym}
+      # end
+      # 
+      # def roles_list     
+      #   [roles].flatten
+      # end      
     end
 
     extend Roles::Generic::User::Configuration

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

@@ -1,3 +1,5 @@
+require 'roles_mongoid/strategy/multi'
+
 module RoleStrategy::Mongoid
   module RolesMask
     def self.default_role_attribute
@@ -20,7 +22,7 @@ module RoleStrategy::Mongoid
         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)
@@ -35,6 +37,8 @@ module RoleStrategy::Mongoid
     end
 
     module Implementation 
+      include Roles::Mongoid::Strategy::Multi
+
       class Roles < ::Set # :nodoc:
         attr_reader :model_instance
 
@@ -49,30 +53,75 @@ module RoleStrategy::Mongoid
         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)
-        self.send("#{role_attribute}=", (roles.flatten.map { |r| r.to_sym } & strategy_class.valid_roles).map { |r| calc_index(r) }.inject { |sum, bitvalue| sum + bitvalue })
+      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 set_empty_roles
+        self.send("#{role_attribute}=", 0)
+      end
+      
+      def present_roles *role_names
+        role_names.to_a.to_symbols
+      end
 
-      def calc_index(r)
-        2**strategy_class.valid_roles.index(r)
+      def set_roles *roles
+        roles = roles.flat_uniq
+        roles = roles.first if self.class.role_strategy.multiplicity == :single
+        vrs = new_roles roles
+        self.send("#{role_attribute}=", vrs)
       end
+
+            
+      # class Roles < ::Set # :nodoc:
+      #   attr_reader :model_instance
+      # 
+      #   def initialize(sender, *roles)
+      #     super(*roles)
+      #     @model_instance = sender
+      #   end
+      # 
+      #   def <<(role)
+      #     model_instance.roles = super.to_a
+      #     self
+      #   end
+      # end
+      # 
+      # def role_attribute
+      #   strategy_class.roles_attribute_name
+      # end 
+      # 
+      # # assign roles
+      # def roles=(*roles)
+      #   self.send("#{role_attribute}=", (roles.flatten.map { |r| r.to_sym } & strategy_class.valid_roles).map { |r| calc_index(r) }.inject { |sum, bitvalue| sum + bitvalue })
+      # 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? })
+      # end
+      # 
+      # def roles_list
+      #   roles.to_a
+      # end        
+      # 
+      # protected
+      # 
+      # def calc_index(r)
+      #   2**strategy_class.valid_roles.index(r)
+      # end 
     end    
     
     extend Roles::Generic::User::Configuration

data/lib/roles_mongoid/strategy/multi.rb

@@ -0,0 +1,59 @@
+require 'roles_mongoid/strategy/shared'
+
+module Roles::Mongoid
+  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)
+        diff = roles_diff(role_names)
+        diff = role_class.find_roles(diff).to_a if self.class.role_strategy.type == :complex
+        set_roles(diff) 
+        true
+      end
+
+      # query assigned roles
+      def roles
+        get_roles.to_a.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
+        roles = roles.flat_uniq
+        roles = roles.first if self.class.role_strategy.multiplicity == :single        
+        # self.send("#{role_attribute}").send(:<<, roles)        
+        self.send("#{role_attribute}=", roles)        
+      end
+
+      def get_roles
+        self.send(role_attribute)
+      end      
+    end
+  end
+end

data/lib/roles_mongoid/strategy/shared.rb

@@ -0,0 +1,29 @@
+module Roles::Mongoid
+  module Strategy
+    module Shared
+      def set_role role
+        raise ArgumentError, "#set_role only takes a single role as argument, not #{role}" if role.kind_of?(Array)
+        self.send("#{role_attribute}=", role)
+      end
+      
+      def set_roles *roles
+        roles = roles.flat_uniq
+        roles = roles.first if self.class.role_strategy.multiplicity == :single        
+        self.send("#{role_attribute}=", roles)
+      end
+            
+      def get_role
+        r = self.send(role_attribute) 
+      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