roles_for_mongoid 0.1.1 → 0.2.0

data/.rspec

@@ -0,0 +1 @@
+--format nested --color

data/README.markdown

@@ -1,125 +1,30 @@
 # Roles for Mongoid
 
-# Install
-
-<code>gem install roles_for_mongoid</code>
-
-# Usage
-
-The library comes with the following role models built-in:
-
-* Single inline role (string)
-* Multiple inline role (strings)
-* Multiple role relations (many relationship using array of object ids)
-
-Note: The following examples use RSpec to demonstrate usage scenarios.
-
-## Example : Admin flag
-
-<pre>
-require 'roles_for_mongoid'
-
-User.role_strategy :admin_flag
-
-before :each do
-  guest_user = User.new :name => 'Kristian', :role => 'guest'
-  admin_user = User.new :name => 'Admin user', :role => 'admin' 
-  admin_user.save                                        
-  guest_user.save
-end
-
-it "should return first user maching role" do
-  User.in_role('guest').first.name.should == 'Kristian'
-  User.in_role('admin').first.name.should == 'Admin user'
-end
-</pre>
-
-
-## Example : Single inline role
-
-<pre>
-User.role_strategy :inline_role
+A Mongoid implementation of [roles generic](http://github.com/kristianmandrup/roles_generic)
 
-before :each do
-  guest_user = User.new :name => 'Kristian', :role => 'guest'
-  admin_user = User.new :name => 'Admin user', :role => 'admin' 
-  admin_user.save                                        
-  guest_user.save
-end
-
-it "should return first user maching role" do
-  User.in_role('guest').first.name.should == 'Kristian'
-  User.in_role('admin').first.name.should == 'Admin user'
-end
-</pre>
-
-## Example : Multiple inline roles
-
-<pre>
-User.role_strategy :inline_roles
-
-before :each do
-  guest_user = User.new(:name => 'Kristian', :roles => ['guest']).save
-  admin_user = User.new(:name => 'Admin user', :roles => ['admin']).save
-  author_user = User.new(:name => 'Author', :roles => ['author']).save
-end
-
-it "should return first user matching role" do
-  User.in_role('admin').first.name.should == 'Admin user'
-end
-
-it "should return all users matching any of the roles" do
-  User.in_roles(['guest', 'admin']).all.size.should == 2
-  User.in_roles('guest', 'admin').all.size.should == 2
-end
-</pre>
-    
-## Example : Multiple role relations
-
-<pre>
-User.role_strategy :role_relations
-
-before :each do
-  guest_user = User.new(:name => 'Kristian')
-  admin_user = User.new(:name => 'Admin user')
-  author_user = User.new(:name => 'Author')
+# Install
 
-  guest_user.roles << Role.new(:name => 'guest')
-  guest_user.save      
+<code>gem install roles_mongoid</code>
 
-  admin_user.roles << Role.new(:name => 'admin')
-  admin_user.save      
-  
-  author_user.roles << Role.new(:name => 'author')
-  author_user.save      
-end    
+## Status: Sept 6, 2010
 
-it "should return first user matching role" do
-  User.in_role('guest').first.name.should == 'Kristian'
-  User.in_role('admin').first.name.should == 'Admin user'
-end
+Implements the [roles generic](http://github.com/kristianmandrup/roles_generic) Roles API
+It also implements the following Role strategies:
 
-it "should return all users matching any of the roles" do
-  User.in_roles(['guest', 'admin']).all.size.should == 2
-  User.in_roles('guest', 'admin').all.size.should == 2 
-end
-</pre>
+* admin_flag
+* many_roles
+* one_role
+* roles_mask
+* role_string
+* role_strings
 
 ## Rails generator
 
-The library comes with a Rails 3 generator that lets you populate a user model with a given role strategy 
-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.
-
-* admin_flag
-* inline_role
-* inline_roles
-* role_relations
-* role_mask
+Might work but needs testing ;)
 
 Example:
 
-<code>$ rails g mongoid:roles user admin_flag</code>
-
+<code>$ rails g mongoid:roles User --strategy admin_flag --roles admin guest</code>
 
 ## Note on Patches/Pull Requests
  

data/Rakefile

@@ -7,7 +7,11 @@ begin
     gem.email = "kmandrup@gmail.com"
     gem.homepage = "http://github.com/kristianmandrup/roles_for_mm"
     gem.authors = ["Kristian Mandrup"]
-    gem.add_development_dependency "rspec", ">= 2.0.0.beta.17"
+    gem.add_development_dependency "rspec", ">= 2.0.0.beta.19"
+    gem.add_dependency "mongoid", '~> 2.0.0.beta.17'
+    gem.add_dependency "require_all", '~> 1.1.0' 
+    gem.add_dependency "sugar-high", '~> 0.2.3'        
+    gem.add_dependency "roles_generic", '~> 0.2.2'        
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/generators/mongoid/roles/roles_generator.rb

@@ -1,45 +1,68 @@
-module Mongoid 
+require 'rails3_artifactor'
+
+module RolesModel 
   module Generators
     class RolesGenerator < Rails::Generators::NamedBase
-      desc "Generate roles model for User" 
+      include Rails3::Assist::Artifact::Model
+      
+      desc "Add role strategy to a model" 
       
-      argument :role_strategy, :type => :string, :aliases => "-r", :default => 'inline_role', :desc => "Create roles model for user"
+      class_option :strategy, :type => :string, :aliases => "-s", :default => 'role_string', 
+                   :desc => "Role strategy to use (admin_flag, role_string, roles_string, role_strings, one_role, many_roles, roles_mask)"
+
+
+      class_option :roles, :type => :array, :aliases => "-r", :default => [], :desc => "Valid roles"
 
-      hook_for :orm
+      # hook_for :orm
             
-      def apply_role_strategy   
-        insert_into_model(model_name, role_strategy_statement)
+      # def self.source_root
+      #   @source_root ||= File.expand_path("../../templates", __FILE__)
+      # end
+
+      def apply_role_strategy        
+        self.class.use_orm orm if orm
+        insert_into_model name do
+          insertion_text
+        end
       end 
       
       protected                  
 
-      def model_name
-        name
+      def orm
+        :mongoid
+      end
+
+      def default_roles
+        [:admin, :guest]        
       end
 
-      def match_expr
-        /include Mongoid::Document/
+      def roles_to_add
+        default_roles.concat(options[:roles]).compact.uniq
+      end
+
+      def roles
+        @roles ||= roles_to_add.map{|r| ":#{r}" }
       end
 
       def role_strategy_statement 
-        "role_strategy #{role_strategy}"        
+        "strategy :#{strategy}\n"
       end
 
-      def role_strategy
-        options[:role_strategy]                
+      def roles_statement
+        roles ? "valid_roles #{roles.join(',')}" : ''
+      end
+
+      def insertion_text
+        %Q{  
+  include Roles::#{orm.to_s.camelize} 
+  #{role_strategy_statement}
+  #{roles_statement}
+}
+      end
+
+      def strategy
+        options[:strategy]                
       end
-      
-      def model_file(name)                          
-        File.join(Rails.root, "app/models/#{name.to_s}.rb")        
-      end
-        
-      def insert_into_model(m_name, insert_text)
-        file = File.new(model_file(m_name))
-        return if (file.read =~ /#{insert_text}/) 
-        gsub_file model_file(m_name), match_expr do |match|
-          match << insert_text
-        end
-      end              
     end
   end
 end

data/lib/roles_mongoid.rb

@@ -0,0 +1,9 @@
+require 'roles_generic'
+require 'require_all'    
+require 'set'
+require 'sugar-high/array'
+require 'mongoid'
+require 'bson'
+require 'roles_mongoid/namespaces'
+require 'roles_mongoid/base'
+require 'roles_mongoid/strategy'

data/lib/roles_mongoid/base.rb

@@ -0,0 +1,35 @@
+module Roles::Base
+  def valid_roles_are(*role_list)
+    strategy_class.valid_roles = role_list.to_symbols
+  end
+end
+
+module Roles
+  module Mongoid  
+    def self.included(base) 
+      base.extend Roles::Base
+      base.extend ClassMethods
+      base.orm_name = :mongoid
+    end
+
+    module ClassMethods
+      
+      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",
+        :role_string  => "field :role_string, :type => String",
+        :role_strings => "field :role_strings, :type => Array",
+        :roles_string => "field :roles_string, :type => String"
+      }
+      
+      def strategy name, options=nil
+        if options == :default && MAP[name]
+          instance_eval MAP[name] 
+        end
+        role_strategy name, options
+      end    
+    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,28 @@
+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 Mongoid::Document
+  field :name, :type => String
+  referenced_in :user
+
+  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/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/many_roles.rb

@@ -0,0 +1,65 @@
+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_roles(role_name)
+      end
+
+      def in_roles(*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      
+        rescue
+          return []
+        end
+      end  
+    end
+    
+    module Implementation
+      def role_attribute
+        strategy_class.roles_attribute_name
+      end 
+      
+      # assign roles
+      def 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
+      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.many_roles << 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_mongoid/strategy/multi/role_strings.rb

@@ -0,0 +1,63 @@
+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_roles(role_name)
+      end
+
+      def in_roles(*role_names)
+        begin
+          where(role_attribute.in => role_names).to_a      
+        rescue
+          return []
+        end
+      end  
+    end
+    
+    module Implementation 
+      def role_attribute
+        strategy_class.roles_attribute_name
+      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
+    configure            
+  end
+end