third-prestige-rolify 3.3.0.rc5

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

@@ -0,0 +1,26 @@
+require 'rolify/adapters/base'
+
+module Rolify
+  module Adapter
+    class ResourceAdapter < ResourceAdapterBase
+      def resources_find(roles_table, relation, role_name)
+        resources = relation.joins("INNER JOIN #{quote(roles_table)} ON #{quote(roles_table)}.resource_type = '#{relation.to_s}' 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 = ?", Array(role_name), relation.to_s)
+        resources = resources.select("#{quote(relation.table_name)}.*")
+        resources
+      end
+
+      def in(relation, user, role_names)
+        roles = user.roles.where(:name => role_names)
+        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
+
+      private
+
+      def quote(column)
+         ActiveRecord::Base.connection.quote_column_name column
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'rolify/adapters/base'
+
+module Rolify
+  module Adapter
+    class RoleAdapter < RoleAdapterBase
+      def where(relation, *args)
+        conditions, values = build_conditions(relation, args)
+        relation.where(conditions, *values)
+      end
+
+      def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
+        role_class.where(:name => role_name, :resource_type => resource_type, :resource_id => resource_id).first_or_create
+      end
+
+      def add(relation, role)
+        relation.role_ids |= [role.id]
+      end
+
+      def remove(relation, role_name, resource = nil)
+        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(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?
+          end
+        end
+        roles
+      end
+
+      def exists?(relation, column)
+        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)
+        conditions = []
+        values = []
+        args.each do |arg|
+          if arg.is_a? Hash
+            a, v = build_query(arg[:name], arg[:resource])
+          elsif arg.is_a?(String) || arg.is_a?(Symbol)
+            a, v = build_query(arg.to_s)
+          else
+            raise ArgumentError, "Invalid argument type: only hash or string or a symbol allowed"
+          end
+          conditions << a
+          values += v
+        end
+        conditions = conditions.join(' OR ')
+        [ conditions, values ]
+      end
+
+      def build_query(role, resource = nil)
+        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 ((#{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 ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.resource_id = ?))"
+            values << role << resource.class.name << resource.id
+          end
+          query += ")"
+        end
+        [ query, values ]
+      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

@@ -0,0 +1,60 @@
+module Rolify
+  module Adapter
+    class Base
+      def initialize(role_cname, user_cname)
+        @role_cname = role_cname
+        @user_cname = user_cname
+      end
+
+      def role_class
+        @role_cname.constantize
+      end
+      
+      def user_class
+        @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
+    end
+
+    class RoleAdapterBase < Adapter::Base
+      def where(relation, args)
+        raise NotImplementedError.new("You must implement where")
+      end
+
+      def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
+        raise NotImplementedError.new("You must implement find_or_create_by")
+      end
+
+      def add(relation, role_name, resource = nil)
+        raise NotImplementedError.new("You must implement add")
+      end
+
+      def remove(relation, role_name, resource = nil)
+        raise NotImplementedError.new("You must implement delete")
+      end
+
+      def exists?(relation, column)
+        raise NotImplementedError.new("You must implement exists?")
+      end
+    end
+
+    class ResourceAdapterBase < Adapter::Base
+      def resources_find(roles_table, relation, role_name)
+        raise NotImplementedError.new("You must implement resources_find")
+      end
+
+      def in(resources, roles)
+        raise NotImplementedError.new("You must implement in")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'rolify/adapters/base'
+
+module Rolify
+  module Adapter
+    class ResourceAdapter < ResourceAdapterBase
+      def resources_find(roles_table, relation, role_name)
+        roles = roles_table.classify.constantize.where(:name.in => Array(role_name), :resource_type => relation.to_s)
+        resources = []
+        roles.each do |role|
+          if role.resource_id.nil?
+            resources += relation.all
+          else
+            resources << role.resource
+          end
+        end
+        resources.compact.uniq
+      end
+
+      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
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'rolify/adapters/base'
+
+module Rolify
+  module Adapter
+    class RoleAdapter < RoleAdapterBase
+      def where(relation, *args)
+        conditions = build_conditions(relation, args)
+        relation.any_of(*conditions)
+      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, 
+                                          :resource_id => resource_id)
+      end
+
+      def add(relation, role)
+        relation.roles << role
+      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|
+        #  # 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.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).delete(relation)
+          role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty? 
+        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)
+        conditions = []
+        args.each do |arg|
+          if arg.is_a? Hash
+            query = build_query(arg[:name], arg[:resource])
+          elsif arg.is_a?(String) || arg.is_a?(Symbol)
+            query = build_query(arg)
+          else
+            raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"
+          end
+          conditions += query
+        end
+        conditions
+      end
+
+      def build_query(role, resource = nil)
+        return [{ :name => role }] if resource == :any
+        query = [{ :name => role, :resource_type => nil, :resource_id => nil }]
+        if resource
+          query << { :name => role, :resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name), :resource_id => nil }
+          if !resource.is_a? Class
+            query << { :name => role, :resource_type => resource.class.name, :resource_id => resource.id }
+          end
+        end
+        query
+      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

data/lib/rolify/configure.rb

@@ -0,0 +1,56 @@
+module Rolify
+  module Configure
+    @@dynamic_shortcuts = false
+    @@orm = "active_record"
+     
+    def configure(*role_cnames)
+      return if !sanity_check(role_cnames)
+      yield self if block_given?
+    end
+
+    def dynamic_shortcuts
+      @@dynamic_shortcuts
+    end
+
+    def dynamic_shortcuts=(is_dynamic)
+      @@dynamic_shortcuts = is_dynamic
+    end
+
+    def orm
+      @@orm
+    end
+
+    def orm=(orm)
+      @@orm = orm
+    end
+
+    def use_mongoid
+      self.orm = "mongoid"
+    end
+    
+    def use_dynamic_shortcuts
+      self.dynamic_shortcuts = true #if defined?(Rails::Server) || defined?(Rails::Console)
+    end
+
+    def use_defaults
+      configure do |config|
+        config.dynamic_shortcuts = false
+        config.orm = "active_record"
+      end
+    end
+    
+    private
+    
+    def sanity_check(role_cnames)
+      role_cnames = [ "Role" ] if role_cnames.empty?
+      role_cnames.each do |role_cname|
+        role_class = role_cname.constantize
+        if role_class.superclass.to_s == "ActiveRecord" && !role_class.table_exists?
+          warn "[WARN] table '#{role_cname}' doesn't exist. Did you run the migration ? Ignoring rolify config."
+          return false
+        end
+      end
+      true
+    end
+  end
+end

data/lib/rolify/dynamic.rb

@@ -0,0 +1,21 @@
+module Rolify
+  module Dynamic
+    def load_dynamic_methods
+      self.role_class.all.each do |r|
+        define_dynamic_method(r.name, r.resource)
+      end
+    end
+
+    def define_dynamic_method(role_name, resource)
+      class_eval do 
+        define_method("is_#{role_name}?".to_sym) do
+          has_role?("#{role_name}")
+        end if !method_defined?("is_#{role_name}?".to_sym)
+
+        define_method("is_#{role_name}_of?".to_sym) do |arg|
+          has_role?("#{role_name}", arg)
+        end if !method_defined?("is_#{role_name}_of?".to_sym) && resource
+      end
+    end
+  end
+end

data/lib/rolify/finders.rb

@@ -0,0 +1,40 @@
+module Rolify
+  module Finders
+    def with_role(role_name, resource = nil)
+      self.adapter.scope(self, :name => role_name, :resource => resource)
+    end
+
+    def with_all_roles(*args)
+      users = []
+      parse_args(args, users) do |users_to_add|
+        users = users_to_add if users.empty?
+        users &= users_to_add
+        return [] if users.empty?
+      end
+      users
+    end
+
+    def with_any_role(*args)
+      users = []
+      parse_args(args, users) do |users_to_add|
+        users += users_to_add
+      end
+      users.uniq
+    end
+  end
+  
+  private
+  
+  def parse_args(args, users, &block)
+    args.each do |arg|
+      if arg.is_a? Hash
+        users_to_add = self.with_role(arg[:name], arg[:resource])
+      elsif arg.is_a?(String) || arg.is_a?(Symbol)
+        users_to_add = self.with_role(arg)
+      else
+        raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"
+      end
+      block.call(users_to_add)
+    end
+  end
+end