rolify 4.1.1 → 6.0.0

data/lib/rolify/configure.rb

@@ -52,9 +52,8 @@ module Rolify
     private
 
     def sanity_check(role_cnames)
-      return true if (ARGV[0] =~ /assets:/) == 0
+      return true if ARGV.reduce(nil) { |acc,arg| arg =~ /assets:/ if acc.nil? } == 0
 
-      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::Base" && role_table_missing?(role_class)
@@ -67,6 +66,9 @@ module Rolify
 
     def role_table_missing?(role_class)
       !role_class.table_exists?
+    rescue ActiveRecord::NoDatabaseError
+      true
     end
+
   end
 end

data/lib/rolify/dynamic.rb

@@ -2,29 +2,15 @@ require "rolify/configure"
 
 module Rolify
   module Dynamic
-    def load_dynamic_methods
-      if ENV['ADAPTER'] == 'active_record'
-        # supported Rails version >= 3.2 with AR should use find_each, since use of .all.each is deprecated
-        self.role_class.includes(:resource).find_each do |r|
-          define_dynamic_method(r.name, r.resource)
-        end
-      else
-        # for compatibility with MongoidDB and older Rails AR - does not support polymorphic includes
-        self.role_class.all.each do |r|
-          define_dynamic_method(r.name, r.resource)
-        end
-      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)
+        end if !method_defined?("is_#{role_name}?".to_sym) && self.adapter.where_strict(self.role_class, name: role_name).exists?
 
         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 if !method_defined?("is_#{role_name}_of?".to_sym) && resource && self.adapter.where_strict(self.role_class, name: role_name, resource: resource).exists?
       end
     end
   end

data/lib/rolify/finders.rb

@@ -1,7 +1,12 @@
 module Rolify
   module Finders
     def with_role(role_name, resource = nil)
-      self.adapter.scope(self, :name => role_name, :resource => resource)
+      strict = self.strict_rolify and resource and resource != :any
+      self.adapter.scope(
+        self,
+        { :name => role_name, :resource => resource },
+        strict
+      )
     end
 
     def without_role(role_name, resource = nil)

data/lib/rolify/matchers.rb

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

data/lib/rolify/resource.rb

@@ -11,7 +11,7 @@ module Rolify
 
       def with_role(role_name, user = nil)
         if role_name.is_a? Array
-          role_name.map!(&:to_s)
+          role_name = role_name.map(&:to_s)
         else
           role_name = role_name.to_s
         end

data/lib/rolify/role.rb

@@ -44,6 +44,15 @@ module Rolify
       self.class.adapter.where_strict(self.roles, name: role_name, resource: resource).any?
     end
 
+    def has_cached_role?(role_name, resource = nil)
+      return has_strict_cached_role?(role_name, resource) if self.class.strict_rolify and resource and resource != :any
+      self.class.adapter.find_cached(self.roles, name: role_name, resource: resource).any?
+    end
+
+    def has_strict_cached_role?(role_name, resource = nil)
+      self.class.adapter.find_cached_strict(self.roles, name: role_name, resource: resource).any?
+    end
+
     def has_all_roles?(*args)
       args.each do |arg|
         if arg.is_a? Hash
@@ -77,7 +86,7 @@ module Rolify
     deprecate :has_no_role, :remove_role
 
     def roles_name
-      self.roles.select(:name).map { |r| r.name }
+      self.roles.pluck(:name)
     end
 
     def method_missing(method, *args, &block)
@@ -85,7 +94,7 @@ module Rolify
         resource = args.first
         self.class.define_dynamic_method $1, resource
         return has_role?("#{$1}", resource)
-      end unless !Rolify.dynamic_shortcuts
+      end if Rolify.dynamic_shortcuts
       super
     end
 

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "4.1.1"
+  VERSION = "6.0.0"
 end

data/rolify.gemspec

@@ -9,20 +9,28 @@ Gem::Specification.new do |s|
   s.version     = Rolify::VERSION
   s.platform    = Gem::Platform::RUBY
   s.homepage    = 'https://github.com/RolifyCommunity/rolify'
-  s.rubyforge_project = s.name
 
   s.license     = 'MIT'
 
-  s.authors     = ['Florent Monbillard']
-  s.email       = ['f.monbillard@gmail.com']
+  s.authors     = [
+    'Florent Monbillard',
+    'Wellington Cordeiro'
+  ]
+  s.email       = [
+    'f.monbillard@gmail.com',
+    'wellington@wellingtoncordeiro.com'
+  ]
 
   s.files         = `git ls-files`.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']
 
-  s.add_development_dependency 'ammeter',     '~> 1.1.2' # Spec generator
-  s.add_development_dependency 'bundler',     '>= 1.7.12' # packaging feature
-  s.add_development_dependency 'rake',        '~> 10.4.2' # Tasks manager
-  s.add_development_dependency 'rspec-rails', '2.99.0'
+  s.required_ruby_version = '>= 2.5'
+
+  s.add_development_dependency 'ammeter',     '~> 1.1' # Spec generator
+  s.add_development_dependency 'appraisal',   '~> 2.0'
+  s.add_development_dependency 'bundler',     '~> 2.0' # packaging feature
+  s.add_development_dependency 'rake',        '~> 12.3' # Tasks manager
+  s.add_development_dependency 'rspec-rails', '~> 3.8'
 end

data/spec/common_helper.rb

@@ -0,0 +1,16 @@
+require 'test-unit'
+
+begin
+  require 'pry'
+rescue LoadError
+end
+
+# `Test::Unit::AutoRunner.need_auto_run=` was introduced to the test-unit
+# gem in version 2.4.9. Previous to this version `Test::Unit.run=` was
+# used. The implementation of test-unit included with Ruby has neither
+# method.
+if defined? Test::Unit::AutoRunner
+  Test::Unit::AutoRunner.need_auto_run = false
+elsif defined?(Test::Unit)
+  Test::Unit.run = false
+end

data/spec/generators/rolify/rolify_activerecord_generator_spec.rb

@@ -8,6 +8,7 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
   destination File.expand_path("../../../../tmp", __FILE__)
   teardown :cleanup_destination_root
 
+  let(:adapter) { 'SQLite3Adapter' }
   before {
     prepare_destination
   }
@@ -20,6 +21,8 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
     before(:all) { arguments %w(Role) }
 
     before {
+      allow(ActiveRecord::Base).to receive_message_chain(
+        'connection.class.to_s.demodulize') { adapter }
       capture(:stdout) {
         generator.create_file "app/models/user.rb" do
           <<-RUBY
@@ -43,12 +46,32 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
     describe 'app/models/role.rb' do
       subject { file('app/models/role.rb') }
       it { should exist }
-      it { should contain "class Role < ActiveRecord::Base" }
+      it do
+        if Rails::VERSION::MAJOR < 5
+          should contain "class Role < ActiveRecord::Base"
+        else
+          should contain "class Role < ApplicationRecord"
+        end
+      end
       it { should contain "has_and_belongs_to_many :users, :join_table => :users_roles" }
-      it { should contain "belongs_to :resource, :polymorphic => true" }
+      it do
+        if Rails::VERSION::MAJOR < 5
+          should contain "belongs_to :resource,\n"
+                          "           :polymorphic => true"
+        else
+          should contain "belongs_to :resource,\n"
+                          "           :polymorphic => true,\n"
+                          "           :optional => true"
+        end
+      end
+      it { should contain "belongs_to :resource,\n"
+                          "           :polymorphic => true,\n"
+                          "           :optional => true"
+      }
       it { should contain "validates :resource_type,\n"
                           "          :inclusion => { :in => Rolify.resource_types },\n"
                           "          :allow_nil => true" }
+      it { should contain "scopify" }
     end
 
     describe 'app/models/user.rb' do
@@ -62,6 +85,24 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
       it { should be_a_migration }
       it { should contain "create_table(:roles) do" }
       it { should contain "create_table(:users_roles, :id => false) do" }
+
+      context 'mysql2' do
+        let(:adapter) { 'Mysql2Adapter' }
+
+        it { expect(subject).to contain('add_index(:roles, :name)') }
+      end
+
+      context 'sqlite3' do
+        let(:adapter) { 'SQLite3Adapter' }
+
+        it { expect(subject).to contain('add_index(:roles, :name)') }
+      end
+
+      context 'pg' do
+        let(:adapter) { 'PostgreSQLAdapter' }
+
+        it { expect(subject).not_to contain('add_index(:roles, :name)') }
+      end
     end
   end
 
@@ -69,6 +110,8 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
     before(:all) { arguments %w(AdminRole AdminUser) }
 
     before {
+      allow(ActiveRecord::Base).to receive_message_chain(
+        'connection.class.to_s.demodulize') { adapter }
       capture(:stdout) {
         generator.create_file "app/models/admin_user.rb" do
           "class AdminUser < ActiveRecord::Base\nend"
@@ -91,9 +134,18 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
       subject { file('app/models/admin_role.rb') }
 
       it { should exist }
-      it { should contain "class AdminRole < ActiveRecord::Base" }
+      it do
+        if Rails::VERSION::MAJOR < 5
+          should contain "class AdminRole < ActiveRecord::Base"
+        else
+          should contain "class AdminRole < ApplicationRecord"
+        end
+      end
       it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
-      it { should contain "belongs_to :resource, :polymorphic => true" }
+      it { should contain "belongs_to :resource,\n"
+                          "           :polymorphic => true,\n"
+                          "           :optional => true"
+      }
     end
 
     describe 'app/models/admin_user.rb' do
@@ -108,6 +160,24 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
       it { should be_a_migration }
       it { should contain "create_table(:admin_roles)" }
       it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+
+      context 'mysql2' do
+        let(:adapter) { 'Mysql2Adapter' }
+
+        it { expect(subject).to contain('add_index(:admin_roles, :name)') }
+      end
+
+      context 'sqlite3' do
+        let(:adapter) { 'SQLite3Adapter' }
+
+        it { expect(subject).to contain('add_index(:admin_roles, :name)') }
+      end
+
+      context 'pg' do
+        let(:adapter) { 'PostgreSQLAdapter' }
+
+        it { expect(subject).not_to contain('add_index(:admin_roles, :name)') }
+      end
     end
   end
 
@@ -115,6 +185,8 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
     before(:all) { arguments %w(Admin::Role Admin::User) }
 
     before {
+      allow(ActiveRecord::Base).to receive_message_chain(
+        'connection.class.to_s.demodulize') { adapter }
       capture(:stdout) {
         generator.create_file "app/models/admin/user.rb" do
           <<-RUBY
@@ -143,9 +215,18 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
       subject { file('app/models/admin/role.rb') }
 
       it { should exist }
-      it { should contain "class Admin::Role < ActiveRecord::Base" }
+      it do
+        if Rails::VERSION::MAJOR < 5
+          should contain "class Admin::Role < ActiveRecord::Base"
+        else
+          should contain "class Admin::Role < ApplicationRecord"
+        end
+      end
       it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
-      it { should contain "belongs_to :resource, :polymorphic => true" }
+      it { should contain "belongs_to :resource,\n"
+                          "           :polymorphic => true,\n"
+                          "           :optional => true"
+      }
     end
 
     describe 'app/models/admin/user.rb' do
@@ -160,6 +241,31 @@ describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_r
       it { should be_a_migration }
       it { should contain "create_table(:admin_roles)" }
       it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+      it do
+        if Rails::VERSION::MAJOR < 5
+          should contain "< ActiveRecord::Migration"
+        else
+          should contain "< ActiveRecord::Migration[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      context 'mysql2' do
+        let(:adapter) { 'Mysql2Adapter' }
+
+        it { expect(subject).to contain('add_index(:admin_roles, :name)') }
+      end
+
+      context 'sqlite3' do
+        let(:adapter) { 'SQLite3Adapter' }
+
+        it { expect(subject).to contain('add_index(:admin_roles, :name)') }
+      end
+
+      context 'pg' do
+        let(:adapter) { 'PostgreSQLAdapter' }
+
+        it { expect(subject).not_to contain('add_index(:admin_roles, :name)') }
+      end
     end
   end
 end

data/spec/generators_helper.rb

@@ -1,21 +1,28 @@
 require 'rubygems'
 require "bundler/setup"
 
+require 'pry'
+
 require 'rolify'
 require 'rolify/matchers'
-require 'rails'
+require 'rails/all'
 require_relative 'support/stream_helpers'
 include StreamHelpers
 
 require 'coveralls'
 Coveralls.wear_merged!
 
+require 'common_helper'
+
 ENV['ADAPTER'] ||= 'active_record'
 
 if ENV['ADAPTER'] == 'active_record'
+  load File.dirname(__FILE__) + '/support/adapters/utils/active_record.rb'
   require 'active_record/railtie'
+  establish_connection
 else
-  require 'mongoid'
+  load File.dirname(__FILE__) + '/support/adapters/utils/mongoid.rb'
+  load_mongoid_config
 end
 
 module TestApp

data/spec/rolify/config_spec.rb

@@ -161,6 +161,8 @@ describe Rolify do
         config.orm = "mongoid"
       end
     end
+
+    subject { Rolify }
     
     its(:dynamic_shortcuts) { should be_truthy }
     its(:orm) { should eq("mongoid") }

data/spec/rolify/custom_spec.rb

@@ -17,4 +17,4 @@ describe "Using Rolify with custom User and Role class names" do
   it_behaves_like "Role.scopes"
   it_behaves_like Rolify::Dynamic
   it_behaves_like "Rolify.callbacks"
-end
+end

data/spec/rolify/resource_spec.rb

@@ -542,29 +542,35 @@ describe Rolify::Resource do
     context "strict user" do
       before(:all) do
         @strict_user = StrictUser.first
+        @strict_user.role_ids
         @strict_user.add_role(:forum, Forum.first)
         @strict_user.add_role(:forum, Forum)
       end
 
       it "should return only strict forum" do
         @strict_user.has_role?(:forum, Forum.first).should be true
+        @strict_user.has_cached_role?(:forum, Forum.first).should be true
       end
 
       it "should return false on strict another forum" do
         @strict_user.has_role?(:forum, Forum.last).should be false
+        @strict_user.has_cached_role?(:forum, Forum.last).should be false
       end
 
       it "should return true if user has role on Forum model" do
         @strict_user.has_role?(:forum, Forum).should be true
+        @strict_user.has_cached_role?(:forum, Forum).should be true
       end
 
       it "should return true if user has role any forum name" do
         @strict_user.has_role?(:forum, :any).should be true
+        @strict_user.has_cached_role?(:forum, :any).should be true
       end
 
       it "should return false when deleted role on Forum model" do
         @strict_user.remove_role(:forum, Forum)
         @strict_user.has_role?(:forum, Forum).should be false
+        @strict_user.has_cached_role?(:forum, Forum).should be false
       end
     end
   end