rolify 3.2.0 → 3.3.0

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/{role/templates → templates}/initializer.rb

@@ -1,6 +1,6 @@
-Rolify.configure do |config|
+Rolify.configure<%= "(\"#{class_name.camelize.to_s}\")" if class_name != "Role" %> do |config|
   # By default ORM adapter is ActiveRecord. uncomment to use mongoid
-  <%= "# " if orm_adapter == "active_record" %>config.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
   # Enable this feature _after_ running rake db:migrate as it relies on the roles table

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,8 +5,6 @@ class <%= role_cname.camelize %>
   belongs_to :resource, :polymorphic => true
   
   field :name, :type => String
-  index({ :name => 1 }, { :unique => true })
-
 
   index({
     :name => 1,

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,25 +1,26 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter   
+  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)}.id)")
+        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.to_s.tableize)}.id IN (?) AND ((resource_id = #{quote(relation.table_name)}.id) OR (resource_id IS NULL))", roles)
+        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
+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,13 +17,14 @@ 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? 
+          roles.each do |role|
+            role.destroy if role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?
           end
         end
         roles
@@ -32,9 +33,13 @@ module Rolify
       def exists?(relation, column)
         relation.where("#{column} IS NOT NULL")
       end
-      
+
       def scope(relation, conditions)
-        query = relation.scoped
+        if Rails.version < "4.0"
+          query = relation.scoped
+        else
+          query = relation.all
+        end
         query = query.joins(:roles)
         query = where(query, conditions)
         query
@@ -66,10 +71,10 @@ module Rolify
         values = [ role ]
         if resource
           query.insert(0, "(")
-          query += " OR ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.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 ((#{role_table}.name = ?) AND (#{role_table}.resource_type = ?) AND (#{role_table}.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 += ")"
@@ -78,4 +83,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/adapters/base.rb

@@ -15,7 +15,7 @@ module Rolify
       end
       
       def role_table
-        @role_cname.tableize
+        role_class.table_name
       end
       
       def self.create(adapter, role_cname, user_cname)

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

@@ -1,7 +1,7 @@
 require 'rolify/adapters/base'
 
 module Rolify
-  module Adapter  
+  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)
@@ -13,7 +13,7 @@ module Rolify
             resources << role.resource
           end
         end
-        resources.uniq
+        resources.compact.uniq
       end
 
       def in(resources, user, role_names)

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

@@ -19,20 +19,30 @@ 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|
-          # 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
+        #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)

data/lib/rolify/configure.rb

@@ -3,7 +3,8 @@ module Rolify
     @@dynamic_shortcuts = false
     @@orm = "active_record"
      
-    def configure
+    def configure(*role_cnames)
+      return if !sanity_check(role_cnames)
       yield self if block_given?
     end
 
@@ -37,5 +38,19 @@ module Rolify
         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/finders.rb

@@ -6,14 +6,7 @@ module Rolify
 
     def with_all_roles(*args)
       users = []
-      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
+      parse_args(args, users) do |users_to_add|
         users = users_to_add if users.empty?
         users &= users_to_add
         return [] if users.empty?
@@ -23,17 +16,25 @@ module Rolify
 
     def with_any_role(*args)
       users = []
-      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
+      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

data/lib/rolify/matchers.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :have_role do |*args|
+  match do |resource|
+    resource.has_role?(*args)
+  end
+
+  failure_message_for_should do |resource|
+    "expected to have role #{args.map(&:inspect).join(" ")}"
+  end
+
+  failure_message_for_should_not do |resource|
+    "expected not to have role #{args.map(&:inspect).join(" ")}"
+  end
+end

data/lib/rolify/railtie.rb

@@ -3,7 +3,7 @@ require 'rails'
 
 module Rolify
   class Railtie < Rails::Railtie
-    initializer 'rolify.initialize' do
+    initializer 'rolify.initialize', :after do
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.send :extend, Rolify
       end

data/lib/rolify/resource.rb

@@ -8,12 +8,17 @@ module Rolify
       def find_roles(role_name = nil, user = nil)
         roles = user && (user != :any) ? user.roles : self.role_class
         roles = roles.where(:resource_type => self.to_s)
-        roles = roles.where(:name => role_name) if role_name && (role_name != :any)
+        roles = roles.where(:name => role_name.to_s) if role_name && (role_name != :any)
         roles
       end
 
       def with_role(role_name, user = nil)
-        resources = self.adapter.resources_find(self.role_class.to_s.tableize, self, role_name)
+        if role_name.is_a? Array
+          role_name.map!(&:to_s)
+        else
+          role_name = role_name.to_s
+        end
+        resources = self.adapter.resources_find(self.role_table_name, self, role_name)
         user ? self.adapter.in(resources, user, role_name) : resources
       end
       alias :with_roles :with_role

data/lib/rolify/role.rb

@@ -52,7 +52,7 @@ module Rolify
     end
 
     def remove_role(role_name, resource = nil)
-      self.class.adapter.remove(self, role_name, resource)
+      self.class.adapter.remove(self, role_name.to_s, resource)
     end
     
     alias_method :revoke, :remove_role
@@ -64,11 +64,9 @@ module Rolify
 
     def method_missing(method, *args, &block)
       if method.to_s.match(/^is_(\w+)_of[?]$/) || method.to_s.match(/^is_(\w+)[?]$/)
-        if self.class.role_class.where(:name => $1).count > 0
-          resource = args.first
-          self.class.define_dynamic_method $1, resource
-          return has_role?("#{$1}", resource)
-        end
+        resource = args.first
+        self.class.define_dynamic_method $1, resource
+        return has_role?("#{$1}", resource)
       end unless !Rolify.dynamic_shortcuts
       super
     end
@@ -84,4 +82,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "3.2.0"
+  VERSION = "3.3.0"
 end

data/lib/rolify.rb

@@ -9,42 +9,48 @@ require 'rolify/adapters/base'
 module Rolify
   extend Configure
 
-  attr_accessor :role_cname, :adapter
+  attr_accessor :role_cname, :adapter, :role_join_table_name, :role_table_name
 
   def rolify(options = {})
     include Role
     extend Dynamic if Rolify.dynamic_shortcuts
-    
+
     options.reverse_merge!({:role_cname => 'Role'})
+    self.role_cname = options[:role_cname]
+    self.role_table_name = self.role_cname.tableize.gsub(/\//, "_")
+
+    default_join_table = "#{self.to_s.tableize.gsub(/\//, "_")}_#{self.role_table_name}"
+    options.reverse_merge!({:role_join_table_name => default_join_table})
+    self.role_join_table_name = options[:role_join_table_name]
 
     rolify_options = { :class_name => options[:role_cname].camelize }
-    rolify_options.merge!({ :join_table => "#{self.to_s.tableize}_#{options[:role_cname].tableize}" }) if Rolify.orm == "active_record"
-    rolify_options.merge!(options.select{ |k,v| [:before_add, :after_add, :before_remove, :after_remove].include? k.to_sym }) if Rolify.orm == "active_record"
+    rolify_options.merge!({ :join_table => self.role_join_table_name }) if Rolify.orm == "active_record"
+    rolify_options.merge!(options.reject{ |k,v| ![ :before_add, :after_add, :before_remove, :after_remove ].include? k.to_sym })
 
     has_and_belongs_to_many :roles, rolify_options
 
-    self.adapter = Rolify::Adapter::Base.create("role_adapter", options[:role_cname], self.name)
-    self.role_cname = options[:role_cname]
-    
+    self.adapter = Rolify::Adapter::Base.create("role_adapter", self.role_cname, self.name)
     load_dynamic_methods if Rolify.dynamic_shortcuts
   end
 
-  def resourcify(options = {})
+  def resourcify(association_name = :roles, options = {})
     include Resource
-    
+
     options.reverse_merge!({ :role_cname => 'Role', :dependent => :destroy })
     resourcify_options = { :class_name => options[:role_cname].camelize, :as => :resource, :dependent => options[:dependent] }
-    has_many :roles, resourcify_options
-    
-    self.adapter = Rolify::Adapter::Base.create("resource_adapter", options[:role_cname], self.name)
     self.role_cname = options[:role_cname]
+    self.role_table_name = self.role_cname.tableize.gsub(/\//, "_")
+
+    has_many association_name, resourcify_options
+
+    self.adapter = Rolify::Adapter::Base.create("resource_adapter", self.role_cname, self.name)
   end
-  
+
   def scopify
     require "rolify/adapters/#{Rolify.orm}/scopes.rb"
-    extend Rolify::Adapter::Scopes 
+    extend Rolify::Adapter::Scopes
   end
-  
+
   def role_class
     self.role_cname.constantize
   end

data/rolify.gemspec

@@ -15,22 +15,16 @@ Gem::Specification.new do |s|
   s.rubyforge_project = s.name
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-    s.add_development_dependency "activerecord-jdbcsqlite3-adapter"
-  else
-    s.add_development_dependency "sqlite3"
-    s.add_development_dependency "bson_ext" if RUBY_VERSION < "2.0.0"
-  end
-  s.add_development_dependency "activerecord", ">= 3.1.0"
-  s.add_development_dependency "mongoid", ">= 3.0"
   s.add_development_dependency "ammeter"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", ">= 2.0"
   s.add_development_dependency "rspec-rails", ">= 2.0"
-  s.add_development_dependency "mongoid-rspec", ">= 1.5"
-  s.add_development_dependency "bundler" 
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "fuubar" 
+  s.add_development_dependency "activerecord", ">= 3.2.0"
+  s.add_development_dependency "mongoid", ">= 3.1"
 end

data/spec/README.rdoc

@@ -0,0 +1,24 @@
+= Rolify Specs
+
+== Running the specs
+
+To run the specs first run the +bundle+ command to install the necessary gems and the +rake+ command to run the specs.
+
+  bundle
+  rake
+
+== Model Adapters
+
+Rolify currently supports 2 different ORMs: ActiveRecord and Mongoid. By default it will use Active Record but you can change this by setting the +ADAPTER+ environment variable before running the specs. You can run the +bundle+ command with this as well to ensure you have all the required gems.
+
+  ADAPTER=mongoid bundle
+  ADAPTER=mongoid rake
+
+The different model adapters you can specify are:
+
+* active_record (default)
+* mongoid
+
+You can also run the +spec_all+ rake task to run specs for each adapter.
+
+  rake spec_all