roles_mongoid_zhd 0.4.8

data/lib/roles_mongoid/base_role.rb

@@ -0,0 +1,27 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+    if role_class_name
+      role_list.each do |name| 
+        begin
+          role_class_name.create(:name => name.to_s)
+        rescue
+        end
+      end
+    end
+  end
+end  
+
+module RoleClass
+  module ClassMethods
+    def find_roles(*role_names)
+      where(:name.in => role_names.flatten).to_a
+    end
+
+    def find_role role_name
+      raise ArgumentError, "#find_role takes a single role name as argument, not: #{role_name.inspect}" if !role_name.kind_of_label?
+      res = find_roles(role_name)
+      res ? res.first : res
+    end
+  end
+end

data/lib/roles_mongoid/embedded_role.rb

@@ -0,0 +1,24 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+class Role
+  include Mongoid::Document
+  field :name, :type => String
+  
+  validates_uniqueness_of :name  
+
+  class << self
+    def find_roles(*role_names)
+      where(:name.in => role_names.flatten).to_a
+    end
+
+    def find_role role_name
+      raise ArgumentError, "#find_role takes a single role name as argument, not: #{role_name.inspect}" if !role_name.kind_of_label?
+      res = find_roles(role_name)
+      res ? res.first : res
+    end
+  end
+end  

data/lib/roles_mongoid/namespaces.rb

@@ -0,0 +1,12 @@
+require 'sugar-high/module'
+
+module Roles
+  modules :mongoid do
+    nested_modules :user, :role
+  end
+  modules :base, :strategy
+end   
+
+module RoleStrategy
+  modules :mongoid
+end

data/lib/roles_mongoid/role.rb

@@ -0,0 +1,10 @@
+require 'roles_mongoid/base_role'
+
+class Role
+  include Mongoid::Document
+  field :name, :type => String
+
+  validates_uniqueness_of :name
+
+  extend RoleClass::ClassMethods
+end  

data/lib/roles_mongoid/strategy.rb

@@ -0,0 +1,15 @@
+require 'sugar-high/file'
+require 'sugar-high/array'
+
+module Roles::Strategy
+  class << self    
+    def role_dir
+      File.dirname(__FILE__)
+    end    
+
+    def gem_name
+      :roles_mongoid
+    end    
+  end
+end           
+

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/multi/embed_many_roles.rb

@@ -0,0 +1,124 @@
+require 'roles_mongoid/strategy/multi'
+
+module RoleStrategy::Mongoid
+  module EmbedManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        "#{strategy_class.roles_attribute_name.to_s.singularize}_ids".to_sym
+      end
+
+      def in_role(role_name)
+        in_any_role(role_name)
+      end
+
+      def in_any_role(*role_names)
+        begin
+          any_in("many_roles.name" => role_names)
+        rescue
+          return []
+        end
+      end
+    end
+
+    module Implementation
+      include Roles::Mongoid::Strategy::Multi
+
+      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}=", nil)
+        self.send("create_#{role_attribute}").create(:name => role)
+      end      
+
+      def set_roles *roles
+        roles = roles.flat_uniq
+        self.send("#{role_attribute}=", nil)        
+        roles.each do |role|
+          self.send("#{role_attribute}").create(:name => role)
+        end
+      end
+
+      def roles_diff *roles
+        self.roles_list - extract_roles(roles.flat_uniq)
+      end
+
+      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)
+        set_roles(diff) 
+        true
+      end
+
+      def exchange_roles *role_names
+        options = last_option role_names
+        raise ArgumentError, "Must take an options hash as last argument with a :with option signifying which role(s) to replace with" if !options || !options.kind_of?(Hash)
+        common = role_names.to_symbols & roles_list
+        if !common.empty?
+          with_roles = options[:with]
+          set_roles with_roles
+        end
+      end
+
+      def select_valid_roles *role_names
+        role_names = role_names.flat_uniq.select{|role| valid_role? role }        
+      end      
+
+      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
+        
+      # 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
+
+      def new_roles *role_names
+        role_class.find_roles(extract_roles role_names)
+      end
+
+      def present_roles roles_names
+        roles_names.to_a.map{|role| role.name.to_s.to_sym}
+      end
+
+      def set_empty_roles
+        self.send("#{role_attribute}=", [])
+      end
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure :type => :role_class
+  end
+end

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

@@ -0,0 +1,83 @@
+require 'roles_mongoid/strategy/multi'
+
+module RoleStrategy::Mongoid
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        "#{strategy_class.roles_attribute_name.to_s.singularize}_ids".to_sym
+      end
+
+      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)
+          where(:"#{role_attribute}".in => role_ids).to_a
+        rescue
+          return []
+        end
+      end
+    end
+
+    module Implementation
+      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
+        
+      # 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 new_roles *role_names
+        role_class.find_roles(extract_roles role_names)
+      end
+
+      def present_roles roles_names
+        roles_names.to_a.map{|role| role.name.to_s.to_sym}
+      end
+
+      def set_empty_roles
+        self.send("#{role_attribute}=", [])
+      end
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure :type => :role_class
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'roles_mongoid/strategy/multi'
+
+module RoleStrategy::Mongoid
+  module RoleStrings    
+    def self.default_role_attribute
+      :role_strings
+    end    
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end 
+
+      def in_role(role_name)  
+        in_any_role(role_name)
+      end
+
+      def in_any_role(*role_names)
+        begin
+          where(role_attribute.in => role_names).to_a      
+        rescue
+          return []
+        end
+      end  
+    end
+    
+    module Implementation 
+      include Roles::Mongoid::Strategy::Multi
+      
+      def new_roles *roles
+        ::Set.new select_valid_roles(roles)
+      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   
+
+      def present_roles roles_names
+        roles_names.to_a
+      end
+    end
+
+    extend Roles::Generic::User::Configuration
+    configure            
+  end
+end

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

@@ -0,0 +1,130 @@
+require 'roles_mongoid/strategy/multi'
+
+module RoleStrategy::Mongoid
+  module RolesMask
+    def self.default_role_attribute
+      :roles_mask
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def role_attribute
+        strategy_class.roles_attribute_name.to_sym
+      end 
+
+      def in_role(role)     
+        mask = calc_index(role.to_s)
+        all.select do |user| 
+          (user.send(role_attribute) & mask) > 0
+        end
+      end    
+
+      def in_any_role(*roles)
+        all.select do |user| 
+          roles.flatten.any? do |role|
+            mask = calc_index(role.to_s)
+            (user.send(role_attribute) & mask) > 0
+          end
+        end
+      end    
+  
+      def calc_index(r)
+        2**strategy_class.valid_roles.index(r.to_sym)
+      end 
+    end
+
+    module Implementation 
+      include Roles::Mongoid::Strategy::Multi
+
+      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
+
+      protected
+
+      def calc_index(r)
+        2**strategy_class.valid_roles.index(r)
+      end
+
+      def get_roles 
+        strategy_class::Roles.new(self, strategy_class.valid_roles.reject { |r| ((get_role || 0) & calc_index(r)).zero? })        
+      end
+      
+      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 set_empty_roles
+        self.send("#{role_attribute}=", 0)
+      end
+      
+      def present_roles *role_names
+        role_names.to_a.to_symbols
+      end
+
+      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
+    configure            
+  end
+end