roles_mongo_mapper 0.1.4 → 0.2.0

data/README.markdown

@@ -5,7 +5,8 @@ A *Mongo Mapper* implementation of [roles generic](http://github.com/kristianman
 ## Intro
 
 Implements the [roles generic](http://github.com/kristianmandrup/roles_generic) Roles API
-It also implements the following Role strategies:
+
+Generic Role strategies implemented:
 
 * admin_flag
 * many_roles
@@ -14,13 +15,21 @@ It also implements the following Role strategies:
 * role_string
 * role_strings
 
+*Update Nov 24, 2010*
+Version 0.3.1 and up is a major refactoring to support Roles Generic 0.3 and above with a new and improved architecture and testing framework. 
+Since 0.3.2 development of some basic infrastructure to support embedded role strategies in the future has been initiated.
+
+* embed_one_role
+* embed_many_roles
+
+Please join in the effort to implement and add these strategies to the mix.
+
 ## Install
 
 <code>gem install roles_mongo_mapper</code>
 
 ## Rails generator
 
-
 The library comes with a Rails 3 generator that lets you populate a user model with a role strategy of your choice. 
 
 The following role strategies are included by default. Add your own by adding extra files inside the strategy folder, one file for each role strategy is recommended.

data/Rakefile

@@ -8,15 +8,16 @@ begin
     gem.homepage = "http://github.com/kristianmandrup/roles_mongo_mapper"
     gem.authors = ["Kristian Mandrup"]
 
-    gem.add_development_dependency "rspec",           ">= 2.0.0.rc"
+    gem.add_development_dependency "rspec",           ">= 2.1"
     gem.add_development_dependency 'generator-spec',  "~> 0.6.5"
 
-    gem.add_dependency "mongo_mapper",      '~> 0.8.4'
-    gem.add_dependency "activesupport",     '~> 3.0.0'
+    gem.add_dependency "mongo_mapper",      '>= 0.8.4'
+    gem.add_dependency "activesupport",     '~> 3.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 'logging_assist',    '~> 0.1.3'
+    gem.add_dependency "sugar-high",        '~> 0.3.0'
+    gem.add_dependency "roles_generic",     '~> 0.3.3'
+    gem.add_dependency 'rails3_artifactor', '~> 0.3.0'
+    gem.add_dependency 'logging_assist',    '>= 0.1.5'
 
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/lib/roles_mongo_mapper/base.rb

@@ -17,18 +17,35 @@ module Roles::MongoMapper
       :admin_flag   => "key :admin_flag, 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   => "key :roles_mask,    Integer, :default => 1",
+
+      # :embed_many_roles   => "many :many_roles, :class_name => 'Role'",
+      # :embed_one_role     => "one :one_role, :class_name => 'Role'",
+
+      :roles_mask   => "key :roles_mask,    Integer, :default => 0",
       :role_string  => "key :role_string,   String",
       :role_strings => "key :role_strings,  Array",
       :roles_string => "key :roles_string,  String"
     }
     
-    def strategy name, options = nil
-      if options == :default && MAP[name]
+    def strategy name, options = {}
+      if (options == :default || options[:config] == :default) && MAP[name]
         instance_eval MAP[name] 
       end
 
-      role_strategy name, options
+      if !options.kind_of? Symbol
+        role_class = options[:role_class] ? options[:role_class].to_s.camelize.constantize : (Role if defined? Role)
+      end
+
+      # case name
+      # when :embed_one_role
+      #   raise ArgumentError, "#strategy class method must take :role_class option when using an embedded role strategy" if !role_class
+      #   role_class.embedded_in :user, :inverse_of => :one_role
+      # when :embed_many_roles
+      #   raise ArgumentError, "#strategy class method must take :role_class option when using an embedded role strategy" if !role_class
+      #   role_class.embedded_in :user, :inverse_of => :many_roles
+      # end
+      
+      set_role_strategy name, options
     end    
   end
 end

data/lib/roles_mongo_mapper/embedded_role.rb

@@ -0,0 +1,35 @@
+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|
+        role_class_name.create(:name => name.to_s)
+      end
+    end
+  end
+end
+
+class Role
+  include MongoMapper::EmbeddedDocument  
+  key :name, String
+
+  key :user_id, ObjectId
+  belongs_to :user
+  
+  # scope :by_name,  lambda { |name| where(:name => name.to_s) }
+  # scope :by_names,  lambda { |*names| where(:name => names.to_strings) }
+
+  class << self
+    def find_roles(*role_names)  
+      role_names.flatten!
+      by_names(role_names).all
+    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?
+      by_name(role_name).first
+    end
+  end
+end  
+
+

data/lib/roles_mongo_mapper/role.rb

@@ -3,7 +3,7 @@ module Roles::Base
     strategy_class.valid_roles = role_list.to_symbols
     if role_class_name
       role_list.each do |name|
-        role_class_name.create(:name => name.to_s).save
+        role_class_name.create(:name => name.to_s)
       end
     end
   end
@@ -16,11 +16,11 @@ class Role
   scope :by_name,  lambda { |name| where(:name => name.to_s) }
   scope :by_names,  lambda { |*names| where(:name => names.to_strings) }
 
-
   class << self
-    def find_roles(*role_names)
-      # return all(:name => role_names.to_strings)
-      by_names(*role_names).all
+    def find_roles(*role_names)  
+      role_names.flatten!
+      by_names(role_names).all
+      # where(:name => role_names.to_strings).all 
     end
 
     def find_role role_name
@@ -29,3 +29,5 @@ class Role
     end
   end
 end  
+
+

data/lib/roles_mongo_mapper/strategy/multi.rb

@@ -0,0 +1,59 @@
+require 'roles_mongo_mapper/strategy/shared'
+
+module Roles::MongoMapper
+  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_mongo_mapper/strategy/multi/embed_many_roles.rb

@@ -0,0 +1,71 @@
+module RoleStrategy::MongoMapper
+  module ManyRoles
+    def self.default_role_attribute
+      :many_roles
+    end
+
+    def self.included base
+      base.extend Roles::Generic::Role::ClassMethods
+      base.extend ClassMethods
+      base.key :many_roles_ids, Array, :typecast => 'ObjectId'
+      base.many :many_roles, class_name: 'Role', :in => :many_roles_ids 
+      base.ensure_index :many_role_ids     
+    end
+
+    module ClassMethods  
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end       
+
+      def role_id_attribute
+        "#{role_attribute}_ids".to_sym
+      end       
+        
+      def in_role(role_name)
+        role = Role.find_role(role_name)
+        res = all(role_id_attribute => role.id)        
+      end
+
+      def in_roles(*role_names)                          
+        role_ids = Role.find_roles(role_names).map{|role| role.id}
+        all(role_id_attribute.in => role_ids)
+      end
+    end
+    
+    module Implementation
+      def role_id_attribute
+        "#{role_attribute}_ids".to_sym
+      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)
+        save
+      end
+
+      def add_roles(*role_names)  
+        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(*role_names)
+        self.send(role_attribute) << role_relations
+        save
+      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
+    configure :type => :role_class     
+  end
+end
+

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

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/multi'
+
 module RoleStrategy::MongoMapper
   module ManyRoles
     def self.default_role_attribute
@@ -8,7 +10,7 @@ module RoleStrategy::MongoMapper
       base.extend Roles::Generic::Role::ClassMethods
       base.extend ClassMethods
       base.key :many_roles_ids, Array, :typecast => 'ObjectId'
-      base.many :many_roles, class_name: 'Role', :in => :many_roles_ids 
+      base.many :many_roles, :class_name => 'Role', :in => :many_roles_ids 
       base.ensure_index :many_role_ids     
     end
 
@@ -26,42 +28,86 @@ module RoleStrategy::MongoMapper
         res = all(role_id_attribute => role.id)        
       end
 
-      def in_roles(*role_names)                          
+      def in_any_role(*role_names)                          
         role_ids = Role.find_roles(role_names).map{|role| role.id}
         all(role_id_attribute.in => role_ids)
       end
     end
     
-    module Implementation
-      def role_id_attribute
-        "#{role_attribute}_ids".to_sym
+    module Implementation 
+      include Roles::MongoMapper::Strategy::Multi
+
+      def has_roles?(*roles_names)
+        compare_roles = extract_roles(roles_names.flat_uniq)
+        (roles_list & compare_roles).not.empty?      
       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)
-        save
+      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 add_roles(*role_names)  
-        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(*role_names)
-        self.send(role_attribute) << role_relations
-        save
+      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
 
-      # query assigned roles
-      def roles
-        self.send(role_attribute)
+      def new_roles *role_names
+        role_class.find_roles(extract_roles role_names)
       end
 
-      def roles_list     
-        [roles].flatten.map{|r| r.name }.compact.to_symbols
+      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      
+      # def role_id_attribute
+      #   "#{role_attribute}_ids".to_sym
+      # 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)
+      #   save
+      # end
+      # 
+      # def add_roles(*role_names)  
+      #   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(*role_names)
+      #   self.send(role_attribute) << role_relations
+      #   save
+      # 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_mongo_mapper/strategy/multi/role_strings.rb

@@ -1,3 +1,5 @@
+require 'roles_mongo_mapper/strategy/multi'
+
 module RoleStrategy::MongoMapper
   module RoleStrings    
     def self.default_role_attribute
@@ -14,10 +16,10 @@ module RoleStrategy::MongoMapper
       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_strings)
         rescue
@@ -26,31 +28,49 @@ module RoleStrategy::MongoMapper
       end  
     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=
+    module Implementation
+      include Roles::MongoMapper::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)
+      #   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
+      # 
+      # # 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