rolify 3.1.0 → 4.0.0

data/lib/generators/active_record/rolify_generator.rb

@@ -0,0 +1,54 @@
+require 'rails/generators/active_record'
+require 'active_support/core_ext'
+
+module ActiveRecord
+  module Generators
+    class RolifyGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      argument :user_cname, :type => :string, :default => "User", :banner => "User"
+
+      def generate_model
+        invoke "active_record:model", [ name ], :migration => false
+      end
+
+      def inject_role_class
+        inject_into_class(model_path, class_name, model_content)
+      end
+
+      def copy_rolify_migration
+        migration_template "migration.rb", "db/migrate/rolify_create_#{table_name}.rb"
+      end
+
+      def join_table
+        user_cname.constantize.table_name + "_" + table_name
+      end
+
+      def user_reference
+        user_cname.demodulize.underscore
+      end
+
+      def role_reference
+        class_name.demodulize.underscore
+      end
+
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+
+      def model_content
+        content = <<RUBY
+  has_and_belongs_to_many :%{user_cname}, :join_table => :%{join_table}
+  belongs_to :resource, :polymorphic => true
+
+  validates :resource_type,
+            :inclusion => { :in => Rolify.resource_types },
+            :allow_nil => true
+
+  scopify
+RUBY
+        content % { :user_cname => user_cname.constantize.table_name, :join_table => "#{user_cname.constantize.table_name}_#{table_name}"}
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/README

@@ -0,0 +1,8 @@
+Now, you just have to run the migration using rake command:
+
+   rake db:migrate
+
+and you will be able to add the resourcify method inside all models you want 
+scoped by a role.
+
+===============================================================================

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,19 @@
+class RolifyCreate<%= table_name.camelize %> < ActiveRecord::Migration
+  def change
+    create_table(:<%= table_name %>) do |t|
+      t.string :name
+      t.references :resource, :polymorphic => true
+
+      t.timestamps
+    end
+
+    create_table(:<%= join_table %>, :id => false) do |t|
+      t.references :<%= user_reference %>
+      t.references :<%= role_reference %>
+    end
+
+    add_index(:<%= table_name %>, :name)
+    add_index(:<%= table_name %>, [ :name, :resource_type, :resource_id ])
+    add_index(:<%= join_table %>, [ :<%= user_reference %>_id, :<%= role_reference %>_id ])
+  end
+end

data/lib/generators/mongoid/rolify_generator.rb

@@ -0,0 +1,55 @@
+require 'rails/generators/mongoid_generator'
+require 'active_support/core_ext'
+
+module Mongoid
+  module Generators
+    class RolifyGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      argument :user_cname, :type => :string, :default => "User", :banner => "User"
+
+      def generate_model
+        invoke "mongoid:model", [ name ]
+      end
+
+      def inject_role_class
+        inject_into_file(model_path, model_contents, :after => "include Mongoid::Document\n")
+      end
+
+      def user_reference
+        user_cname.demodulize.underscore
+      end
+
+      def role_reference
+        class_name.demodulize.underscore
+      end
+
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+
+      def model_contents
+        content = <<RUBY
+  has_and_belongs_to_many :%{user_cname}
+  belongs_to :resource, :polymorphic => true
+
+  field :name, :type => String
+
+  index({
+    :name => 1,
+    :resource_type => 1,
+    :resource_id => 1
+  },
+  { :unique => true})
+
+  validates :resource_type,
+            :inclusion => { :in => Rolify.resource_types },
+            :allow_nil => true
+
+  scopify
+RUBY
+        content % { :user_cname => user_cname.constantize.collection_name }
+      end
+    end
+  end
+end

data/lib/generators/mongoid/templates/README-mongoid

@@ -0,0 +1,4 @@
+Now, you are able to add the resourcify method inside all models you want 
+scoped by a role.
+
+===============================================================================

data/lib/generators/rolify/rolify_generator.rb

@@ -0,0 +1,35 @@
+module Rolify
+  module Generators
+    class RolifyGenerator < Rails::Generators::NamedBase
+      Rails::Generators::ResourceHelpers
+      
+      source_root File.expand_path('../templates', __FILE__)
+      argument :user_cname, :type => :string, :default => "User"
+
+      namespace :rolify
+      hook_for :orm, :required => true
+
+      desc "Generates a model with the given NAME and a migration file."
+
+      def self.start(args, config)
+        user_cname = args.size > 1 ? args[1] : "User"
+        args.insert(1, user_cname) # 0 being the view name
+        super
+      end
+      
+      def inject_user_class
+        invoke "rolify:user", [ user_cname, class_name ], :orm => options.orm
+      end
+        
+      def copy_initializer_file
+        template "initializer.rb", "config/initializers/rolify.rb"
+      end
+      
+      def show_readme
+        if behavior == :invoke
+          readme "README"
+        end
+      end
+    end
+  end
+end

data/lib/generators/rolify/{role/templates/README-mongoid → templates/README}

@@ -4,14 +4,10 @@ An initializer file has been created here: config/initializers/rolify.rb, you
 can change rolify settings to match your needs. 
 Defaults values are commented out.
 
-A Role class has been been created in app/models (with the name you gave as 
+A Role class has been created in app/models (with the name you gave as 
 argument otherwise the default is role.rb), you can add your own business logic 
 inside.
 
 Inside your User class (or the name you gave as argument otherwise the default 
 is user.rb), rolify method has been inserted to provide rolify methods.
 
-Now, if you are able to add the resourcify method inside all models you want 
-scoped by a role.
-
-===============================================================================

data/lib/generators/rolify/templates/initializer.rb

@@ -0,0 +1,7 @@
+Rolify.configure<%= "(\"#{class_name.camelize.to_s}\")" if class_name != "Role" %> do |config|
+  # By default ORM adapter is ActiveRecord. uncomment to use mongoid
+  <%= "# " if options.orm == :active_record || !options.orm %>config.use_mongoid
+
+  # Dynamic shortcuts for User class (user.is_admin? like methods). Default is: false
+  # config.use_dynamic_shortcuts
+end

data/lib/generators/rolify/templates/role-active_record.rb

@@ -0,0 +1,11 @@
+class <%= role_cname.camelize %> < ActiveRecord::Base
+<% if need_table_prefix?(role_cname) %>
+  def self.table_name_prefix
+    <%= table_prefix(role_cname) %>_
+  end
+<% end %>
+  has_and_belongs_to_many :<%= user_cname.tableize %>, :join_table => :<%= "#{table_name(user_cname, true)}_#{table_name(role_cname, true)}" %>
+  belongs_to :resource, :polymorphic => true
+  
+  scopify
+end

data/lib/generators/rolify/{role/templates → templates}/role-mongoid.rb

@@ -5,13 +5,13 @@ class <%= role_cname.camelize %>
   belongs_to :resource, :polymorphic => true
   
   field :name, :type => String
-  index :name, unique: true
-  index(
-    [
-      [:name, Mongo::ASCENDING],
-      [:resource_type, Mongo::ASCENDING],
-      [:resource_id, Mongo::ASCENDING]
-    ],
-    unique: true
-  )
+
+  index({
+    :name => 1,
+    :resource_type => 1,
+    :resource_id => 1
+  },
+  { :unique => true})
+  
+  scopify
 end

data/lib/generators/rolify/user_generator.rb

@@ -0,0 +1,39 @@
+require 'rails/generators/migration'
+require 'active_support/core_ext'
+
+module Rolify
+  module Generators
+    class UserGenerator < Rails::Generators::NamedBase
+      argument :role_cname, :type => :string, :default => "Role"
+      class_option :orm, :type => :string, :default => "active_record"
+      
+      desc "Inject rolify method in the User class."
+
+      def inject_user_content
+        inject_into_file(model_path, :after => inject_rolify_method) do
+          "  rolify#{role_association}\n"
+        end
+      end
+      
+      def inject_rolify_method
+        if options.orm == :active_record
+          /class #{class_name.camelize}\n|class #{class_name.camelize} .*\n|class #{class_name.demodulize.camelize}\n|class #{class_name.demodulize.camelize} .*\n/
+        else
+          /include Mongoid::Document\n|include Mongoid::Document .*\n/
+        end
+      end
+      
+      def model_path
+        File.join("app", "models", "#{file_path}.rb")
+      end
+      
+      def role_association
+        if role_cname != "Role"
+          " :role_cname => '#{role_cname.camelize}'"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/rolify/adapters/active_record/resource_adapter.rb

@@ -1,17 +1,47 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter   
+  module Adapter
     class ResourceAdapter < ResourceAdapterBase
+      def find_roles(role_name, relation, user)
+        roles = user && (user != :any) ? user.roles : self.role_class
+        roles = roles.where('resource_type IN (?)', self.relation_types_for(relation))
+        roles = roles.where(:name => role_name.to_s) if role_name && (role_name != :any)
+        roles
+      end
+
       def resources_find(roles_table, relation, role_name)
-        resources = relation.joins("INNER JOIN \"#{roles_table}\" ON \"#{roles_table}\".\"resource_type\" = '#{relation.to_s}'")
-        resources = resources.where("#{roles_table}.name = ? AND #{roles_table}.resource_type = ?", role_name, relation.to_s)
+        klasses   = self.relation_types_for(relation)
+        relations = klasses.inject('') do |str, klass|
+          str = "#{str}'#{klass.to_s}'"
+          str << ', ' unless klass == klasses.last
+          str
+        end
+        resources = relation.joins("INNER JOIN #{quote(roles_table)} ON #{quote(roles_table)}.resource_type IN (#{relations}) AND
+                                    (#{quote(roles_table)}.resource_id IS NULL OR #{quote(roles_table)}.resource_id = #{quote(relation.table_name)}.#{relation.primary_key})")
+        resources = resources.where("#{quote(roles_table)}.name IN (?) AND #{quote(roles_table)}.resource_type IN (?)", Array(role_name), klasses)
+        resources = resources.select("#{quote(relation.table_name)}.*")
         resources
       end
 
-      def in(relation, roles)
-        relation.where("#{role_class.to_s.tableize}.id IN (?) AND ((resource_id = #{relation.table_name}.id) OR (resource_id IS NULL))", roles)
+      def in(relation, user, role_names)
+        roles = user.roles.where(:name => role_names).select("#{quote(role_class.table_name)}.#{role_class.primary_key}")
+        relation.where("#{quote(role_class.table_name)}.#{role_class.primary_key} IN (?) AND ((resource_id = #{quote(relation.table_name)}.#{relation.primary_key}) OR (resource_id IS NULL))", roles)
+      end
+
+      def applied_roles(relation, children)
+        if children
+          relation.role_class.where('resource_type IN (?) AND resource_id IS NULL', self.relation_types_for(relation))
+        else
+          relation.role_class.where('resource_type = ? AND resource_id IS NULL', relation.to_s)
+        end
+      end
+
+      private
+
+      def quote(column)
+        ActiveRecord::Base.connection.quote_column_name column
       end
     end
   end
-end
+end

data/lib/rolify/adapters/active_record/role_adapter.rb

@@ -1,7 +1,7 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter   
+  module Adapter
     class RoleAdapter < RoleAdapterBase
       def where(relation, *args)
         conditions, values = build_conditions(relation, args)
@@ -9,7 +9,7 @@ module Rolify
       end
 
       def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
-        role_class.find_or_create_by_name_and_resource_type_and_resource_id(role_name, resource_type, resource_id)
+        role_class.where(:name => role_name, :resource_type => resource_type, :resource_id => resource_id).first_or_create
       end
 
       def add(relation, role)
@@ -17,14 +17,15 @@ module Rolify
       end
 
       def remove(relation, role_name, resource = nil)
-        roles = relation.roles.where(:name => role_name)
-        roles = roles.where(:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)) if resource
-        roles = roles.where(:resource_id => resource.id) if resource && !resource.is_a?(Class)
+        cond = { :name => role_name }
+        cond[:resource_type] = (resource.is_a?(Class) ? resource.to_s : resource.class.name) if resource
+        cond[:resource_id] = resource.id if resource && !resource.is_a?(Class)
+        roles = relation.roles.where(cond)
         if roles
           relation.roles.delete(roles)
-          roles.each do |role| 
-            role.destroy if role.send(user_class.table_name.to_sym).empty? 
-          end
+          roles.each do |role|
+            role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).limit(1).empty?
+          end if Rolify.remove_role_if_empty
         end
         roles
       end
@@ -33,6 +34,17 @@ module Rolify
         relation.where("#{column} IS NOT NULL")
       end
 
+      def scope(relation, conditions)
+        if Rails.version < "4.0"
+          query = relation.scoped
+        else
+          query = relation.all
+        end
+        query = query.joins(:roles)
+        query = where(query, conditions)
+        query
+      end
+
       private
 
       def build_conditions(relation, args)
@@ -54,15 +66,15 @@ module Rolify
       end
 
       def build_query(role, resource = nil)
-        return [ "name = ?", [ role ] ] if resource == :any
-        query = "((name = ?) AND (resource_type IS NULL) AND (resource_id IS NULL))"
+        return [ "#{role_table}.name = ?", [ role ] ] if resource == :any
+        query = "((#{role_table}.name = ?) AND (#{role_table}.resource_type IS NULL) AND (#{role_table}.resource_id IS NULL))"
         values = [ role ]
         if resource
           query.insert(0, "(")
-          query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id IS NULL))" 
+          query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id IS NULL))"
           values << role << (resource.is_a?(Class) ? resource.to_s : resource.class.name)
           if !resource.is_a? Class
-            query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id = ?))" 
+            query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id = ?))"
             values << role << resource.class.name << resource.id
           end
           query += ")"
@@ -71,4 +83,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/adapters/active_record/scopes.rb

@@ -0,0 +1,27 @@
+module Rolify
+  module Adapter
+    module Scopes
+      def global
+        where(:resource_type => nil, :resource_id => nil)
+      end
+      
+      def class_scoped(resource_type = nil)
+        where_conditions = "resource_type IS NOT NULL AND resource_id IS NULL"
+        where_conditions = [ "resource_type = ? AND resource_id IS NULL", resource_type.name ] if resource_type
+        where(where_conditions)
+      end
+      
+      def instance_scoped(resource_type = nil)
+        where_conditions = "resource_type IS NOT NULL AND resource_id IS NOT NULL"
+        if resource_type
+          if resource_type.is_a? Class
+            where_conditions = [ "resource_type = ? AND resource_id IS NOT NULL", resource_type.name ]
+          else
+            where_conditions = [ "resource_type = ? AND resource_id = ?", resource_type.class.name, resource_type.id ]
+          end
+        end
+        where(where_conditions)
+      end
+    end
+  end
+end

data/lib/rolify/adapters/base.rb

@@ -14,10 +14,19 @@ module Rolify
         @user_cname.constantize
       end
       
+      def role_table
+        role_class.table_name
+      end
+      
       def self.create(adapter, role_cname, user_cname)
         load "rolify/adapters/#{Rolify.orm}/#{adapter}.rb"
+        load "rolify/adapters/#{Rolify.orm}/scopes.rb"
         Rolify::Adapter.const_get(adapter.camelize.to_sym).new(role_cname, user_cname)
       end
+
+      def relation_types_for(relation)
+        relation.descendants.map(&:to_s).push(relation.to_s)
+      end
     end
 
     class RoleAdapterBase < Adapter::Base

data/lib/rolify/adapters/mongoid/resource_adapter.rb

@@ -1,23 +1,44 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter  
+  module Adapter
     class ResourceAdapter < ResourceAdapterBase
+
+      def find_roles(role_name, relation, user)
+        roles = user && (user != :any) ? user.roles : self.role_class
+        roles = roles.where(:resource_type.in => self.relation_types_for(relation))
+        roles = roles.where(:name => role_name.to_s) if role_name && (role_name != :any)
+        roles
+      end
+
       def resources_find(roles_table, relation, role_name)
-        roles = roles_table.classify.constantize.where(:name => role_name, :resource_type => relation.to_s)
+        roles = roles_table.classify.constantize.where(:name.in => Array(role_name), :resource_type.in => self.relation_types_for(relation))
         resources = []
         roles.each do |role|
-          return relation.all if role.resource_id.nil?
-          resources << role.resource
+          if role.resource_id.nil?
+            resources += relation.all
+          else
+            resources << role.resource
+          end
         end
-        resources
+        resources.compact.uniq
       end
 
-      def in(resources, roles)
+      def in(resources, user, role_names)
+        roles = user.roles.where(:name.in => Array(role_names))
         return [] if resources.empty? || roles.empty?
         resources.delete_if { |resource| (resource.applied_roles & roles).empty? }
         resources
       end
+
+      def applied_roles(relation, children)
+        if children
+          relation.role_class.where(:resource_type.in => self.relation_types_for(relation), :resource_id => nil)
+        else
+          relation.role_class.where(:resource_type => relation.to_s, :resource_id => nil)
+        end
+      end
+
     end
   end
 end

data/lib/rolify/adapters/mongoid/role_adapter.rb

@@ -9,8 +9,8 @@ module Rolify
       end
 
       def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
-        self.role_class.find_or_create_by(:name => role_name, 
-                                          :resource_type => resource_type, 
+        self.role_class.find_or_create_by(:name => role_name,
+                                          :resource_type => resource_type,
                                           :resource_id => resource_id)
       end
 
@@ -19,21 +19,45 @@ module Rolify
       end
 
       def remove(relation, role_name, resource = nil)
-        roles = { :name => role_name }
-        roles.merge!({:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)}) if resource
-        roles.merge!({ :resource_id => resource.id }) if resource && !resource.is_a?(Class)
-        roles_to_remove = relation.roles.where(roles)
-        roles_to_remove.each do |role|
+        #roles = { :name => role_name }
+        #roles.merge!({:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)}) if resource
+        #roles.merge!({ :resource_id => resource.id }) if resource && !resource.is_a?(Class)
+        #roles_to_remove = relation.roles.where(roles)
+        #roles_to_remove.each do |role|
+        #  # Deletion in n-n relations is unreliable. Sometimes it works, sometimes not.
+        #  # So, this does not work all the time: `relation.roles.delete(role)`
+        #  # @see http://stackoverflow.com/questions/9132596/rails3-mongoid-many-to-many-relation-and-delete-operation
+        #  # We instead remove ids from the Role object and the relation object.
+        #  relation.role_ids.delete(role.id)
+        #  role.send((user_class.to_s.underscore + '_ids').to_sym).delete(relation.id)
+        #
+        #  role.destroy if role.send(user_class.to_s.tableize.to_sym).empty?
+        #end
+        cond = { :name => role_name }
+        cond[:resource_type] = (resource.is_a?(Class) ? resource.to_s : resource.class.name) if resource
+        cond[:resource_id] = resource.id if resource && !resource.is_a?(Class)
+        roles = relation.roles.where(cond)
+        roles.each do |role|
           relation.roles.delete(role)
-          role.reload
-          role.destroy if role.send(user_class.to_s.tableize.to_sym).empty?
-        end
+          role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).delete(relation)
+          if Rolify.remove_role_if_empty && role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?
+            role.destroy
+          end
+        end if roles
+        roles
       end
 
       def exists?(relation, column)
         relation.where(column.to_sym.ne => nil)
       end
 
+      def scope(relation, conditions)
+        roles = where(role_class, conditions).map { |role| role.id }
+        return [] if roles.size.zero?
+        query = relation.any_in(:role_ids => roles)
+        query
+      end
+
       private
 
       def build_conditions(relation, args)
@@ -64,4 +88,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/adapters/mongoid/scopes.rb

@@ -0,0 +1,27 @@
+module Rolify
+  module Adapter
+    module Scopes
+      def global
+        where(:resource_type => nil, :resource_id => nil)
+      end
+      
+      def class_scoped(resource_type = nil)
+        where_conditions = { :resource_type.ne => nil, :resource_id => nil }
+        where_conditions = { :resource_type => resource_type.name, :resource_id => nil } if resource_type
+        where(where_conditions)
+      end
+      
+      def instance_scoped(resource_type = nil)
+        where_conditions = { :resource_type.ne => nil, :resource_id.ne => nil }
+        if resource_type
+          if resource_type.is_a? Class
+            where_conditions = { :resource_type => resource_type.name, :resource_id.ne => nil }
+          else
+            where_conditions = { :resource_type => resource_type.class.name, :resource_id => resource_type.id }
+          end
+        end
+        where(where_conditions)
+      end
+    end
+  end
+end