rolify 3.1.0 → 4.0.0

data/lib/rolify/configure.rb

@@ -2,8 +2,10 @@ module Rolify
   module Configure
     @@dynamic_shortcuts = false
     @@orm = "active_record"
-     
-    def configure
+    @@remove_role_if_empty = true
+
+    def configure(*role_cnames)
+      return if !sanity_check(role_cnames)
       yield self if block_given?
     end
 
@@ -26,9 +28,10 @@ module Rolify
     def use_mongoid
       self.orm = "mongoid"
     end
-    
+
     def use_dynamic_shortcuts
-      self.dynamic_shortcuts = true #if defined?(Rails::Server) || defined?(Rails::Console)
+      return if !sanity_check([])
+      self.dynamic_shortcuts = true
     end
 
     def use_defaults
@@ -37,5 +40,33 @@ module Rolify
         config.orm = "active_record"
       end
     end
+
+    def remove_role_if_empty=(is_remove)
+      @@remove_role_if_empty = is_remove
+    end
+
+    def remove_role_if_empty
+      @@remove_role_if_empty
+    end
+
+    private
+
+    def sanity_check(role_cnames)
+      return true if "assets:precompile"==ARGV[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)
+          warn "[WARN] table '#{role_cname}' doesn't exist. Did you run the migration ? Ignoring rolify config."
+          return false
+        end
+      end
+      true
+    end
+
+    def role_table_missing?(role_class)
+      !role_class.table_exists?
+    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

data/lib/rolify/matchers.rb

@@ -0,0 +1,31 @@
+require 'rspec/expectations'
+
+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
+
+RSpec::Matchers.define :be_the_same_role do |*expected|
+  match do |actual|
+    if expected.size > 1 
+      if expected[1].is_a? Class
+        actual[:name] == expected[0] && actual[:resource_type] == expected[1].to_s
+      else
+        actual[:name] == expected[0] && 
+        actual[:resource_type] == expected[1].class.name &&
+        actual[:resource_id] == expected[1].id
+      end
+    else
+      actual[:name] == expected[0]
+    end
+  end
+end

data/lib/rolify/railtie.rb

@@ -8,7 +8,7 @@ module Rolify
         ActiveRecord::Base.send :extend, Rolify
       end
       
-      config.after_initialize do
+      config.before_initialize do
         ::Mongoid::Document.module_eval do
           def self.included(base)
             base.extend Rolify

data/lib/rolify/resource.rb

@@ -4,22 +4,31 @@ module Rolify
       base.extend ClassMethods
     end
 
-    module ClassMethods 
+    module ClassMethods
       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
+        self.adapter.find_roles(role_name, self, user)
       end
 
       def with_role(role_name, user = nil)
-        resources = self.adapter.resources_find(self.role_class.to_s.tableize, self, role_name)
-        user ? self.adapter.in(resources, user.roles.where(:name => role_name)) : resources
+        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) #.map(&:id)
+        user ? self.adapter.in(resources, user, role_name) : resources
+      end
+      alias :with_roles :with_role
+
+      def applied_roles(children = true)
+        self.adapter.applied_roles(self, children)
       end
     end
-    
+
     def applied_roles
-      self.roles + self.class.role_class.where(:resource_type => self.class.to_s, :resource_id => nil)
+      #self.roles + self.class.role_class.where(:resource_type => self.class.to_s, :resource_id => nil)
+      self.roles + self.class.applied_roles(true)
     end
   end
-end
+end

data/lib/rolify/role.rb

@@ -1,10 +1,17 @@
+require "rolify/finders"
+require "rolify/utils"
+
 module Rolify
   module Role
     extend Utils
-    
+
+    def self.included(base)
+      base.extend Finders
+    end
+
     def add_role(role_name, resource = nil)
-      role = self.class.adapter.find_or_create_by(role_name, 
-                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
+      role = self.class.adapter.find_or_create_by(role_name.to_s,
+                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource),
                                                   (resource.id if resource && !resource.is_a?(Class)))
 
       if !roles.include?(role)
@@ -14,10 +21,16 @@ module Rolify
       role
     end
     alias_method :grant, :add_role
-    deprecate :has_role, :add_role
 
     def has_role?(role_name, resource = nil)
-      self.class.adapter.where(self.roles, :name => role_name, :resource => resource).size > 0
+      if new_record?
+        role_array = self.roles.detect { |r| r.name.to_s == role_name.to_s && (r.resource == resource || resource.nil?) }
+      else
+        role_array = self.class.adapter.where(self.roles, name: role_name, resource: resource)
+      end
+
+      return false if role_array.nil?
+      role_array != []
     end
 
     def has_all_roles?(*args)
@@ -34,12 +47,21 @@ module Rolify
     end
 
     def has_any_role?(*args)
-      self.class.adapter.where(self.roles, *args).size > 0
+      if new_record?
+        args.any? { |r| self.has_role?(r) }
+      else
+        self.class.adapter.where(self.roles, *args).size > 0
+      end
+    end
+
+    def only_has_role?(role_name, resource = nil)
+      return self.has_role?(role_name,resource) && self.roles.count == 1
     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
     deprecate :has_no_role, :remove_role
 
@@ -49,11 +71,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
@@ -69,4 +89,4 @@ module Rolify
       end
     end
   end
-end
+end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "3.1.0"
+  VERSION = "4.0.0"
 end

data/lib/rolify.rb

@@ -1,42 +1,68 @@
-require 'rolify/railtie' if defined?(Rails)
-require 'rolify/utils'
-require 'rolify/role'
+require 'rolify/adapters/base'
 require 'rolify/configure'
 require 'rolify/dynamic'
+require 'rolify/railtie' if defined?(Rails)
 require 'rolify/resource'
-require 'rolify/adapters/base'
+require 'rolify/role'
 
 module Rolify
   extend Configure
 
-  attr_accessor :role_cname, :adapter
+  attr_accessor :role_cname, :adapter, :role_join_table_name, :role_table_name
+  @@resource_types = []
 
-  def rolify(options = { :role_cname => 'Role' })
+  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!({ :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 = { :role_cname => 'Role' })
+  def adapter
+    return self.superclass.adapter unless self.instance_variable_defined? '@adapter'
+    @adapter
+  end
+
+  def resourcify(association_name = :roles, options = {})
     include Resource
-    
-    resourcify_options = { :class_name => options[:role_cname].camelize }
-    resourcify_options.merge!({ :as => :resource })
-    has_many :roles, resourcify_options
-    
-    self.adapter = Rolify::Adapter::Base.create("resource_adapter", options[:role_cname], self.name)
+
+    options.reverse_merge!({ :role_cname => 'Role', :dependent => :destroy })
+    resourcify_options = { :class_name => options[:role_cname].camelize, :as => :resource, :dependent => options[:dependent] }
     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)
+    @@resource_types << self.name
   end
-  
+
+  def scopify
+    require "rolify/adapters/#{Rolify.orm}/scopes.rb"
+    extend Rolify::Adapter::Scopes
+  end
+
   def role_class
+    return self.superclass.role_class unless self.instance_variable_defined? '@role_cname'
     self.role_cname.constantize
   end
-end
+
+  def self.resource_types
+    @@resource_types
+  end
+end

data/rolify.gemspec

@@ -1,34 +1,28 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "rolify/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'rolify/version'
 
 Gem::Specification.new do |s|
-  s.name        = "rolify"
+  s.name        = 'rolify'
+  s.summary     = %q{Roles library with resource scoping}
+  s.description = %q{Very simple Roles library without any authorization enforcement supporting scope on resource objects (instance or class). Supports ActiveRecord and Mongoid ORMs.}
   s.version     = Rolify::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Florent Monbillard"]
-  s.email       = ["f.monbillard@gmail.com"]
-  s.homepage    = "https://github.com/EppO/rolify"
-  s.summary     = %q{Roles library with resource scoping}
-  s.description = %q{Very simple Roles library without any authorization enforcement supporting scope on resource objects (instance or class)}
-
+  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.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"
-  end
-  s.add_development_dependency "activerecord", ">= 3.1.0"
-  s.add_development_dependency "mongoid", ">= 2.3"
-  s.add_development_dependency "bson_ext"
-  s.add_development_dependency "ammeter"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "bundler" 
+  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'
 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

data/spec/generators/rolify/rolify_activerecord_generator_spec.rb

@@ -0,0 +1,165 @@
+require 'generators_helper'
+
+# Generators are not automatically loaded by Rails
+require 'generators/rolify/rolify_generator'
+
+describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_record' do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../tmp", __FILE__)
+  teardown :cleanup_destination_root
+
+  before {
+    prepare_destination
+  }
+
+  def cleanup_destination_root
+    FileUtils.rm_rf destination_root
+  end
+
+  describe 'specifying only Role class name' do
+    before(:all) { arguments %w(Role) }
+
+    before {
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+          <<-RUBY
+          class User < ActiveRecord::Base
+          end
+          RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/user.rb")
+      run_generator
+    }
+
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.configure do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+
+    describe 'app/models/role.rb' do
+      subject { file('app/models/role.rb') }
+      it { should exist }
+      it { should contain "class Role < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :users, :join_table => :users_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+      it { should contain "validates :resource_type,\n"
+                          "          :inclusion => { :in => Rolify.resource_types },\n"
+                          "          :allow_nil => true" }
+    end
+
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain /class User < ActiveRecord::Base\n  rolify\n/ }
+    end
+
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_roles.rb') }
+
+      it { should be_a_migration }
+      it { should contain "create_table(:roles) do" }
+      it { should contain "create_table(:users_roles, :id => false) do" }
+    end
+  end
+
+  describe 'specifying User and Role class names' do
+    before(:all) { arguments %w(AdminRole AdminUser) }
+
+    before {
+      capture(:stdout) {
+        generator.create_file "app/models/admin_user.rb" do
+          "class AdminUser < ActiveRecord::Base\nend"
+        end
+      }
+      require File.join(destination_root, "app/models/admin_user.rb")
+      run_generator
+    }
+
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+
+      it { should exist }
+      it { should contain "Rolify.configure(\"AdminRole\") do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+
+    describe 'app/models/admin_role.rb' do
+      subject { file('app/models/admin_role.rb') }
+
+      it { should exist }
+      it { should contain "class AdminRole < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+
+    describe 'app/models/admin_user.rb' do
+      subject { file('app/models/admin_user.rb') }
+
+      it { should contain /class AdminUser < ActiveRecord::Base\n  rolify :role_cname => 'AdminRole'\n/ }
+    end
+
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_admin_roles.rb') }
+
+      it { should be_a_migration }
+      it { should contain "create_table(:admin_roles)" }
+      it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+    end
+  end
+
+  describe 'specifying namespaced User and Role class names' do
+    before(:all) { arguments %w(Admin::Role Admin::User) }
+
+    before {
+      capture(:stdout) {
+        generator.create_file "app/models/admin/user.rb" do
+          <<-RUBY
+          module Admin
+            class User < ActiveRecord::Base
+              self.table_name_prefix = 'admin_'
+            end
+          end
+          RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/admin/user.rb")
+      run_generator
+    }
+
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+
+      it { should exist }
+      it { should contain "Rolify.configure(\"Admin::Role\") do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+
+    describe 'app/models/admin/role.rb' do
+      subject { file('app/models/admin/role.rb') }
+
+      it { should exist }
+      it { should contain "class Admin::Role < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+
+    describe 'app/models/admin/user.rb' do
+      subject { file('app/models/admin/user.rb') }
+
+      it { should contain /class User < ActiveRecord::Base\n  rolify :role_cname => 'Admin::Role'\n/ }
+    end
+
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_admin_roles.rb') }
+
+      it { should be_a_migration }
+      it { should contain "create_table(:admin_roles)" }
+      it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+    end
+  end
+end