roles_mongo_mapper 0.1.4 → 0.2.0

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

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/multi'
+
 module RoleStrategy::MongoMapper
   module RolesMask
     def self.default_role_attribute
@@ -20,7 +22,7 @@ module RoleStrategy::MongoMapper
         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::MongoMapper
       end 
     end
 
-    module Implementation 
+    module Implementation    
+      include Roles::MongoMapper::Strategy::Multi
+
       class Roles < ::Set # :nodoc:
         attr_reader :model_instance
 
@@ -49,30 +53,74 @@ module RoleStrategy::MongoMapper
         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_mongo_mapper/strategy/shared.rb

@@ -0,0 +1,29 @@
+module Roles::MongoMapper
+  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}=", new_role(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 = 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_mongo_mapper/strategy/single.rb

@@ -0,0 +1,34 @@
+require 'roles_mongo_mapper/strategy/shared'
+
+class Symbol
+  def admin?
+    self == :admin
+  end
+end
+
+module Roles::MongoMapper
+  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) 
+        the_role = new_roles.first if !new_roles.empty?
+        set_role new_role(the_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

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

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/single'
+
 module RoleStrategy::MongoMapper
   module AdminFlag
     
@@ -15,7 +17,7 @@ module RoleStrategy::MongoMapper
       end
            
       def in_role(role_name) 
-        case role_name.downcase.to_sym
+        case role_name.downcase.to_sym          
         when :admin
           where(role_attribute => true)
         else
@@ -24,23 +26,56 @@ module RoleStrategy::MongoMapper
       end
     end
 
-    module Implementation          
-      # 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
+    module Implementation
+      include Roles::MongoMapper::Strategy::Single
+
+      # 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?
+        vrs = select_valid_roles role_names
+        set_roles(vrs)
       end
 
-      # query assigned roles
-      def roles
-        role = self.send(role_attribute) ? strategy_class.admin_role_key : strategy_class.default_role_key
-        [role]
+      def set_roles *roles
+        set_role roles.flatten.first
+      end
+
+      def new_role role
+        role = role.kind_of?(Array) ? role.flatten.first : role
+        role.kind_of?(Symbol) ? role.admin? : role
+      end
+      
+      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
-      alias_method :roles_list, :roles
+      #                 
+      # # 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
+      # 
+      # # query assigned roles
+      # def roles
+      #   role = self.send(role_attribute) ? strategy_class.admin_role_key : strategy_class.default_role_key
+      #   [role]
+      # end
+      # alias_method :roles_list, :roles
 
     end # Implementation
     

data/lib/roles_mongo_mapper/strategy/single/embed_one_role.rb

@@ -0,0 +1,79 @@
+require 'roles_mongo_mapper/strategy/single'
+
+module RoleStrategy::MongoMapper
+  module EmbedOneRole
+    def self.default_role_attribute
+      :embed_one_role
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+      base.one :one_role, :class_name => 'Role'
+    end
+
+    module ClassMethods 
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end       
+
+      def role_id_attribute
+        "#{role_attribute}_id".to_sym
+      end       
+               
+      def in_role(role_name)  
+        in_any_role(role_name)
+      end
+
+      def in_any_role(*role_names)
+        begin
+          role_ids = Role.find_roles(role_names).map(&:id)
+          all("#{role_attribute}._id" => role_ids)
+        rescue 
+          return []
+        end
+      end  
+    end
+
+    module Implementation
+      include Roles::MongoMapper::Strategy::Single
+
+      def add_roles *role_names
+        new_roles = select_valid_roles(role_names) 
+        the_role = new_roles.first if !new_roles.empty?
+        set_role new_role(the_role)
+      end
+
+      def set_role role
+        raise ArgumentError, "#set_role only takes a single role as argument, not #{role}" if role.kind_of?(Array)
+        the_role = new_role(role)
+        self.send("#{role_attribute}=", the_role)
+        # self.one_role_id = the_role.id
+      end
+            
+      def new_role role
+        role_class.find_role(extract_role role)        
+      end  
+      
+      def new_roles *roles
+        new_role roles.flatten.first
+      end     
+      
+      def present_roles *roles
+        roles.map{|role| extract_role role}
+      end                 
+      
+      def set_empty_role
+        self.send("#{role_attribute}=", nil)
+      end
+
+      def select_valid_roles *role_names
+        role_names = role_names.flat_uniq.select{|role| valid_role? role }
+        has_role_class? ? role_class.find_roles(role_names).to_a : role_names
+      end
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure :num => :single, :type => :role_class
+  end  
+end

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

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/single'
+
 module RoleStrategy::MongoMapper
   module OneRole
     def self.default_role_attribute
@@ -21,19 +23,14 @@ module RoleStrategy::MongoMapper
       end       
                
       def in_role(role_name)  
-        begin
-          role = Role.find_role(role_name)
-          all(role_id_attribute => role.id)
-        rescue
-          return []
-        end
+        in_any_role(role_name)
       end
 
-      def in_roles(*role_names)
+      def in_any_role(*role_names)
         begin
-          role_ids = Role.find_roles(role_names)
-          my_id = send(role_attribute).id
-          all(role_id_attribute.in => role_ids)
+          role_ids = Role.find_roles(role_names).map(&:id)
+          all("#{role_attribute}._id" => role_ids)
+          # all(role_id_attribute.in => role_ids)
         rescue 
           return []
         end
@@ -41,30 +38,41 @@ module RoleStrategy::MongoMapper
     end
 
     module Implementation
-      def role_id_attribute
-        "#{role_attribute}_id".to_sym
-      end       
-            
-      # assign roles
-      def roles=(*_roles)      
-        _roles = get_roles(_roles)
-        return nil if _roles.none?                
+      include Roles::MongoMapper::Strategy::Single
 
-        role_relation = role_class.find_role(_roles.first)
-        if role_relation
-          self.send("#{role_attribute}=", role_relation)
-          self.send("#{role_id_attribute}=", role_relation.id)
-          self.save
-        end
+      def add_roles *role_names
+        new_roles = select_valid_roles(role_names) 
+        the_role = new_roles.first if !new_roles.empty?
+        set_role new_role(the_role)
       end
-      alias_method :role=, :roles=
-      
-      # query assigned roles
-      def roles
-        [self.send(role_attribute).name.to_sym]
+
+      def set_role role
+        raise ArgumentError, "#set_role only takes a single role as argument, not #{role}" if role.kind_of?(Array)
+        the_role = new_role(role)
+        self.send("#{role_attribute}=", the_role)
+        # self.one_role_id = the_role.id
       end
-      alias_method :roles_list, :roles
             
+      def new_role role
+        role_class.find_role(extract_role role)        
+      end  
+      
+      def new_roles *roles
+        new_role roles.flatten.first
+      end     
+      
+      def present_roles *roles
+        roles.map{|role| extract_role role}
+      end                 
+      
+      def set_empty_role
+        self.send("#{role_attribute}=", nil)
+      end
+
+      def select_valid_roles *role_names
+        role_names = role_names.flat_uniq.select{|role| valid_role? role }
+        has_role_class? ? role_class.find_roles(role_names).to_a : role_names
+      end
     end
 
     extend Roles::Generic::User::Configuration

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

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/single'
+
 module RoleStrategy::MongoMapper
   module RoleString    
     def self.default_role_attribute
@@ -19,28 +21,28 @@ module RoleStrategy::MongoMapper
     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 
+    module Implementation
+      include Roles::MongoMapper::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