roles_data_mapper 0.1.3 → 0.2.0

data/Rakefile

@@ -7,19 +7,19 @@ 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 "rspec", ">= 2.0.1"
 
     gem.add_dependency "dm-core",       "~> 1.0"
     gem.add_dependency "dm-types",      "~> 1.0"
     gem.add_dependency "dm-migrations", "~> 1.0"
 
-    gem.add_dependency "activesupport",     "~> 3.0.0"
+    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'
+    gem.add_dependency "sugar-high",        '>= 0.3.0'
+    gem.add_dependency "roles_generic",     '>= 0.3.1'
 
-    gem.add_dependency 'rails3_artifactor', '>= 0.2.6'
-    gem.add_dependency 'logging_assist',    '>= 0.1.5'
+    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

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/lib/roles_data_mapper/base.rb

@@ -15,8 +15,8 @@ module Roles
     module ClassMethods
       
       MAP = {
-        :admin_flag   => "property :admin_flag,   ::DataMapper::Property::Flag[:admin, :default]",
-        :roles_mask   => "property :roles_mask,   Integer, :default => 1",
+        :admin_flag   => "property :admin_flag,   ::DataMapper::Property::Flag[:admin, :guest]",
+        :roles_mask   => "property :roles_mask,   Integer, :default => 0",
         :role_string  => "property :role_string,  String",
         :roles_string => "property :roles_string, String"
       }
@@ -25,7 +25,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_data_mapper/strategy/multi/many_roles.rb

@@ -1,3 +1,5 @@
+require 'roles_data_mapper/strategy/multi'
+
 class Role
   def self.named role_names 
     where(:name.in => role_names.flatten)
@@ -41,43 +43,67 @@ module RoleStrategy::DataMapper
         all("user_roles.role_id" => role.id)
       end
 
-      def in_roles(*roles)                          
+      def in_any_role(*roles)                          
         role_ids = Role.all(:name.in => roles.flatten).map{|role| role.id}
         all("user_roles.role_id" => role_ids)
       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?                
-        
-        role_relations = role_class.find_roles(_roles) 
-        self.send("#{role_attribute}=", role_relations)
-        self.save
+    module Implementation 
+      include Roles::DataMapper::Strategy::Multi
+
+      # 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)
-        role_relations.each do |rel|
-          self.send(role_attribute) << rel
-        end
+      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
+      #       
+      # def role_attribute
+      #   strategy_class.roles_attribute_name
+      # end 
+      # 
+      # # assign roles
+      # def roles=(*_roles)  
+      #   _roles = get_roles(_roles)
+      #   return nil if roles.none?                
+      #   
+      #   role_relations = role_class.find_roles(_roles) 
+      #   self.send("#{role_attribute}=", role_relations)
+      #   self.save
+      # 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)
+      #   role_relations.each do |rel|
+      #     self.send(role_attribute) << rel
+      #   end
+      # end
+      # 
+      # # query assigned roles
+      # def roles
+      #   self.send(role_attribute)
+      # end
+      # 
+      # def roles_list     
+      #   [roles].flatten.map{|r| r.name }.compact.to_symbols
+      # end
     end 
     
     extend Roles::Generic::User::Configuration

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

@@ -1,3 +1,5 @@
+require 'roles_data_mapper/strategy/multi'
+
 module RoleStrategy::DataMapper
   module RolesMask
     def self.default_role_attribute
@@ -20,21 +22,27 @@ module RoleStrategy::DataMapper
         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)
-            (user.send(role_attribute) & mask) > 0
+            if mask
+              (user.send(role_attribute) & mask) > 0              
+            end
           end
         end
       end    
   
       def calc_index(r)
-        2**strategy_class.valid_roles.index(r.to_sym)
+        idx = strategy_class.valid_roles.index(r.to_sym)
+        return nil if !idx
+        2**idx
       end 
     end
 
-    module Implementation 
+    module Implementation
+      include Roles::DataMapper::Strategy::Multi      
+
       class Roles < ::Set # :nodoc:
         attr_reader :model_instance
 
@@ -49,31 +57,70 @@ module RoleStrategy::DataMapper
         end
       end
 
-      def role_attribute
-        strategy_class.roles_attribute_name
-      end 
+      protected
+
+      def calc_index(r)                       
+        self.class.calc_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 calc_index(r)
-        2**strategy_class.valid_roles.index(r)
+      def set_empty_roles
+        self.send("#{role_attribute}=", 0)
       end
-    end    
+      
+      def present_roles *role_names
+        role_names.to_a.to_symbols
+      end
+    end
+
+    # module Implementation 
+    #   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            

data/lib/roles_data_mapper/strategy/multi.rb

@@ -0,0 +1,54 @@
+require 'roles_data_mapper/strategy/shared'
+
+module Roles::DataMapper
+  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_data_mapper/strategy/shared.rb

@@ -0,0 +1,26 @@
+module Roles::DataMapper
+  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_data_mapper/strategy/single/admin_flag.rb

@@ -1,4 +1,4 @@
-puts "AF"
+require 'roles_data_mapper/strategy/single'
 
 module RoleStrategy::DataMapper
   module AdminFlag    
@@ -15,40 +15,73 @@ module RoleStrategy::DataMapper
         strategy_class.roles_attribute_name.to_sym
       end
            
-      def in_role(role_name) 
+      def in_role(role_name)
+        puts "in role: #{role_name}" 
         case role_name.downcase.to_sym
         when :admin
           all(role_attribute => :admin)
         else
-          all(role_attribute => :default)
+          all(role_attribute => :guest)
         end          
       end
+
+      def in_any_role(*role_names)
+        role_names = role_names.flatten
+        all(role_attribute => role_names)
+      end
     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)        
-          value = first_role.admin? ? :admin : :default
-          self.send("#{role_attribute}=", value) 
-        else
-          raise ArgumentError, "The role #{first_role} is not a valid role"
-        end
-      end
+      include Roles::DataMapper::Strategy::Single
 
-      # query assigned roles
-      def roles        
-        role = self.send(role_attribute).include?(:admin) ? strategy_class.admin_role_key : strategy_class.default_role_key
-        [role]
+      def has_roles?(*roles_names)
+        compare_roles = extract_roles(roles_names.flat_uniq)
+        (roles_list & compare_roles).not.empty?      
       end
-      alias_method :roles_list, :roles
 
+      def new_role role
+        role = role.kind_of?(Array) ? role.flatten.first : role
+        role.to_sym
+        # role.admin?
+      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  
+      end   
+      
+      def set_empty_role
+        self.send("#{role_attribute}=", :guest)
+      end      
     end # Implementation
+    # 
+    # 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)        
+    #       value = first_role.admin? ? :admin : :default
+    #       self.send("#{role_attribute}=", value) 
+    #     else
+    #       raise ArgumentError, "The role #{first_role} is not a valid role"
+    #     end
+    #   end
+    # 
+    #   # query assigned roles
+    #   def roles        
+    #     role = self.send(role_attribute).include?(:admin) ? strategy_class.admin_role_key : strategy_class.default_role_key
+    #     [role]
+    #   end
+    #   alias_method :roles_list, :roles
+    # 
+    # end # Implementation 
     
     extend Roles::Generic::User::Configuration
     configure :num => :single

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

@@ -1,9 +1,12 @@
+require 'roles_data_mapper/strategy/single'
+
 class Role
   def self.named role_names 
     where(:name.in => role_names.flatten)
   end
 
-  belongs_to :user, :required => false
+  # belongs_to :user, :required => false
+  # has n, :users, :child_key => [ :one_role ]  
 end
 
 module RoleStrategy::DataMapper
@@ -15,43 +18,51 @@ module RoleStrategy::DataMapper
     def self.included base
       base.extend Roles::Generic::Role::ClassMethods
       base.extend ClassMethods
-      base.instance_eval "has 1, :one_role, 'Role'" # , :parent_key => [role_id], :child_key => [:id]
+      # base.instance_eval "has 1, :one_role, 'Role'" # , :parent_key => [role_id], :child_key => [:id]  
+      base.instance_eval "belongs_to :one_role, :class_name => 'Role'" # :foreign_key => :role_id
     end
 
     module ClassMethods 
-      def role_attribute
-        strategy_class.roles_attribute_name.to_sym
-      end       
+      # def role_attribute
+      #   strategy_class.roles_attribute_name.to_sym
+      # end       
          
       def in_role(role_name)                          
         role = Role.all(:name => role_name).first
-        all('one_role.id' => role.id)
+        # puts "in role: #{role.inspect}, id: #{role.id}"
+        all(:one_role_id => role.id)
       end
 
-      def in_roles(*roles)                          
+      def in_any_role(*roles)                          
         role_ids = Role.all(:name.in => roles.flatten).map{|role| role.id}
-        all(:'one_role.id'.in => role_ids)
+        all(:one_role_id => role_ids)
       end
     end
 
-    module Implementation      
-      # assign roles
-      def roles=(*_roles)      
-        return nil if _roles.none?
-        _roles = get_roles(_roles)        
+    module Implementation
+      include Roles::DataMapper::Strategy::Single
+      
+      def new_role role
+        role_class.find_role(extract_role role)
+      end
 
-        role_relation = role_class.find_role(_roles.first)  
-        self.send("#{role_attribute}=", role_relation)
-        save
+      def new_roles *roles
+        new_role roles.flatten.first
       end
-      alias_method :role=, :roles=
-      
-      # query assigned roles
-      def roles
-        role = self.send(role_attribute)
-        role ? [role.name.to_sym] : []        
+
+      def remove_roles *role_names
+        roles = role_names.flat_uniq
+        set_empty_role if roles_diff(roles).empty?
+        true
+      end 
+
+      def present_roles *roles
+        roles.map{|role| extract_role role}
+      end
+
+      def set_empty_role
+        self.send("#{role_attribute}=", nil)
       end
-      alias_method :roles_list, :roles
     end
 
     extend Roles::Generic::User::Configuration

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

@@ -1,3 +1,5 @@
+require 'roles_data_mapper/strategy/single'
+
 module RoleStrategy::DataMapper
   module RoleString    
     def self.default_role_attribute
@@ -18,29 +20,28 @@ module RoleStrategy::DataMapper
       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::DataMapper::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_data_mapper/strategy/single.rb

@@ -0,0 +1,34 @@
+require 'roles_data_mapper/strategy/shared'
+
+class Symbol
+  def admin?
+    self == :admin
+  end
+end
+
+module Roles::DataMapper
+  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