rolify 2.2.2 → 3.0.0

data/lib/rolify/role.rb

@@ -1,80 +1,51 @@
 module Rolify
-  @@role_cname = "Role"
-  @@user_cname = "User"
-  @@dynamic_shortcuts = false
-  
-  def self.configure
-    yield self if block_given?
-  end
-
-  def self.role_cname
-    @@role_cname.constantize
-  end
-
-  def self.role_cname=(role_cname)
-    @@role_cname = role_cname.camelize
-  end
-
-  def self.user_cname
-    @@user_cname.constantize
-  end
-
-  def self.user_cname=(user_cname)
-    @@user_cname = user_cname.camelize
-  end
-
-  def self.dynamic_shortcuts
-    @@dynamic_shortcuts || false
-  end
-
-  def self.dynamic_shortcuts=(is_dynamic)
-    @@dynamic_shortcuts = is_dynamic
-    self.user_cname.load_dynamic_methods if is_dynamic
-  end
-
-  module Roles
-
+  module Role
     def has_role(role_name, resource = nil)
-      role = Rolify.role_cname.find_or_create_by_name_and_resource_type_and_resource_id(role_name, 
-                                                                                        (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
-                                                                                        (resource.id if resource && !resource.is_a?(Class)))
+      role = self.class.adapter.find_or_create_by(role_name, 
+                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
+                                                  (resource.id if resource && !resource.is_a?(Class)))
+
       if !roles.include?(role)
         self.class.define_dynamic_method(role_name, resource) if Rolify.dynamic_shortcuts
-        self.role_ids |= [role.id]
+        self.class.adapter.add(self, role)
       end
+      role
     end
     alias_method :grant, :has_role
-  
+
     def has_role?(role_name, resource = nil)
-      query, values = build_query(role_name, resource)
-      self.roles.where(query, *values).size > 0
+      self.class.adapter.find(self.roles, role_name, resource).size > 0
     end
 
     def has_all_roles?(*args)
-      conditions, values, count = sql_conditions(args, true)
-      self.roles.where([ conditions.join(' OR '), *values ]).where(count.join(') AND (')).size > 0
+      args.each do |arg|
+        if arg.is_a? Hash
+          return false if !self.has_role?(arg[:name], arg[:resource])
+        elsif arg.is_a?(String) || arg.is_a?(Symbol)
+          return false if !self.has_role?(arg)
+        else
+          raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"
+        end
+      end
+      true
     end
 
     def has_any_role?(*args)
-      conditions, values = sql_conditions(args)
-      self.roles.where([ conditions.join(' OR '), *values ]).size > 0
+      self.class.adapter.where(self.roles, args).size > 0
     end
-  
+
     def has_no_role(role_name, resource = nil)
-      role = self.roles.where(:name => role_name)
-      role = role.where(:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)) if resource
-      role = role.where(:resource_id => resource.id) if resource && !resource.is_a?(Class)
-      self.roles.delete(role) if role
+      self.class.adapter.remove(self.roles, role_name, resource)
     end
     alias_method :revoke, :has_no_role
-  
+
     def roles_name
       self.roles.select(:name).map { |r| r.name }
     end
 
     def method_missing(method, *args, &block)
       if method.to_s.match(/^is_(\w+)_of[?]$/) || method.to_s.match(/^is_(\w+)[?]$/)
-        if Rolify.role_cname.where(:name => $1).count > 0
+        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)
@@ -82,65 +53,16 @@ module Rolify
       end unless !Rolify.dynamic_shortcuts
       super
     end
- 
-    private
- 
-    def sql_conditions(args, count = false)
-      conditions = []
-      count_conditions = [] if count
-      values = []
-      args.each do |arg|
-        if arg.is_a? Hash
-          a, v = build_query(arg[:name], arg[:resource])
-        elsif arg.is_a? String
-          a, v = build_query(arg)
-        else
-          raise ArgumentError, "Invalid argument type: only hash or string allowed"
-        end
-        conditions << a
-        count_conditions << self.roles.where(a, *v).select("COUNT(id)").to_sql + " > 0" if count
-        values += v
-      end
-      count ? [ conditions, values, count_conditions ] : [ conditions, values ]
-    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))"
-      values = [ role ]
-      if resource
-        query.insert(0, "(")
-        query += " OR ((name = ?) AND (resource_type = ?) AND (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 = ?))" 
-          values << role << resource.class.name << resource.id
-        end
-        query += ")"
+    def respond_to?(method, include_private = false)
+      if Rolify.dynamic_shortcuts && (method.to_s.match(/^is_(\w+)_of[?]$/) || method.to_s.match(/^is_(\w+)[?]$/))
+        query = self.class.role_class.where(:name => $1)
+        query = self.class.adapter.exists?(query, :resource_type) if method.to_s.match(/^is_(\w+)_of[?]$/)
+        return true if query.count > 0
+        false
+      else
+        super
       end
-      [ query, values ]
     end
-
-  end
-
-  module Dynamic
- 
-    def load_dynamic_methods
-      Rolify.role_cname.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/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "2.2.2"
+  VERSION = "3.0.0"
 end

data/lib/rolify.rb

@@ -1,4 +1,39 @@
 require 'active_record'
 
+require 'rolify/adapters/active_record' if defined?(ActiveRecord)
+require 'rolify/adapters/mongoid' if defined?(Mongoid)
+require 'rolify/railtie' if defined?(Rails)
 require 'rolify/role'
+require 'rolify/configure'
+require 'rolify/dynamic'
+require 'rolify/resource'
 
+module Rolify
+  extend Configure
+  attr_accessor :role_cname, :adapter
+
+  def rolify(options = { :role_cname => 'Role' })
+    include Role
+    extend Dynamic if Rolify.dynamic_shortcuts
+    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"
+    has_and_belongs_to_many :roles, rolify_options
+
+    load_dynamic_methods if Rolify.dynamic_shortcuts
+    self.role_cname = options[:role_cname]
+    self.adapter = Rolify::Adapter.const_get(Rolify.orm.camelize).new(options[:role_cname])
+  end
+
+  def resourcify(options = { :role_cname => 'Role' })
+    include Resource
+    resourcify_options = { :class_name => options[:role_cname].camelize }
+    resourcify_options.merge!({ :as => :resource })
+    has_many :roles, resourcify_options
+    self.role_cname = options[:role_cname]
+    self.adapter = Rolify::Adapter.const_get(Rolify.orm.camelize).new(options[:role_cname])
+  end
+  
+  def role_class
+    self.role_cname.constantize
+  end
+end

data/rolify.gemspec

@@ -19,13 +19,14 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency "activerecord", ">= 3.1.0"
-  
   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"

data/spec/generators/rolify/role/role_generator_spec.rb

@@ -6,9 +6,15 @@ require 'generators/rolify/role/role_generator'
 describe Rolify::Generators::RoleGenerator 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 'no arguments' do
     before(:all) { arguments [] }
@@ -25,16 +31,20 @@ describe Rolify::Generators::RoleGenerator do
     describe 'config/initializers/rolify.rb' do
       subject { file('config/initializers/rolify.rb') }
       it { should exist }
-      it { should contain "c.user_cname = \"User\"" }
-      it { should contain "c.role_cname = \"Role\"" }
-      it { should contain "c.dynamic_shortcuts = false" }
+      it { should contain "# c.use_dynamic_shortcuts" }
+    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" }
     end
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "include Rolify::Roles" }
-      it { should contain "# extend Rolify::Dynamic" }
-      it { should contain "has_and_belongs_to_many :roles, :join_table => :users_roles" }
+      it { should contain "rolify" }
     end
     
     describe 'migration file' do
@@ -60,16 +70,20 @@ describe Rolify::Generators::RoleGenerator do
     describe 'config/initializers/rolify.rb' do
       subject { file('config/initializers/rolify.rb') }
       it { should exist }
-      it { should contain "c.user_cname = \"Client\"" }
-      it { should contain "c.role_cname = \"Rank\"" }
-      it { should contain "c.dynamic_shortcuts = false" }
+      it { should contain "# c.use_dynamic_shortcuts" }
+    end
+    
+    describe 'app/models/rank.rb' do
+      subject { file('app/models/rank.rb') }
+      it { should exist }
+      it { should contain "class Rank < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :clients, :join_table => :clients_ranks" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
     end
     
     describe 'app/models/client.rb' do
       subject { file('app/models/client.rb') }
-      it { should contain "include Rolify::Roles" }
-      it { should contain "# extend Rolify::Dynamic" }
-      it { should contain "has_and_belongs_to_many :roles, :class_name => \"Rank\", :join_table => :clients_ranks" }
+      it { should contain "rolify" }
     end
     
     describe 'migration file' do
@@ -96,14 +110,20 @@ describe Rolify::Generators::RoleGenerator do
     describe 'config/initializers/rolify.rb' do
       subject { file('config/initializers/rolify.rb') }
       it { should exist }
-      it { should contain "c.dynamic_shortcuts = true" }
+      it { should_not contain "# c.use_dynamic_shortcuts" }
+    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" }
     end
     
     describe 'app/models/user.rb' do
       subject { file('app/models/user.rb') }
-      it { should contain "include Rolify::Roles" }
-      it { should contain "extend Rolify::Dynamic" }
-      it { should contain "has_and_belongs_to_many :roles, :join_table => :users_roles" }
+      it { should contain "rolify" }
     end
     
     describe 'migration file' do
@@ -113,4 +133,43 @@ describe Rolify::Generators::RoleGenerator do
       it { should be_a_migration }
     end
   end
+  
+  describe 'specifying orm adapter' do 
+    before(:all) { arguments [ "Role", "User", "mongoid" ] }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+          <<-CLASS 
+          class User
+            include Mongoid::Document
+
+            field :login, :type => String
+          end
+          CLASS
+        end
+      }
+      run_generator
+    }
+      
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should_not contain "# c.use_mongoid" }
+      it { should contain "# c.use_dynamic_shortcuts" }
+    end
+    
+    describe 'app/models/role.rb' do
+      subject { file('app/models/role.rb') }
+      it { should exist }
+      it { should contain "class Role\n" }
+      it { should contain "has_and_belongs_to_many :users\n" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+    
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain "rolify" }
+    end
+  end
 end

data/spec/rolify/config_spec.rb

@@ -0,0 +1,189 @@
+require "spec_helper"
+
+class ARUser < ActiveRecord::Base
+  extend Rolify
+end
+
+class MUser
+  include Mongoid::Document
+  extend Rolify
+end
+
+describe Rolify do
+  before do
+    Rolify.use_defaults
+  end
+
+  describe :dynamic_shortcuts do 
+    context "using defaults values" do
+      subject { Rolify.dynamic_shortcuts }
+
+      it { should be_false }
+    end
+
+    context "using custom values" do
+      before do
+        Rolify.dynamic_shortcuts = true
+      end
+
+      subject { Rolify.dynamic_shortcuts }
+
+      it { should be_true }
+    end
+  end
+
+  describe :orm do 
+    context "using defaults values" do
+      subject { Rolify.orm }
+
+      it { should eq("active_record") }
+      
+      context "on the User class" do
+        before do
+          ARUser.rolify
+        end
+        
+        subject { ARUser }
+        
+        its("adapter.class") { should be(Rolify::Adapter::ActiveRecord) }
+      end
+      
+      context "on the Forum class" do
+        before do
+          Forum.resourcify
+        end
+        
+        subject { Forum }
+        
+        its("adapter.class") { should be(Rolify::Adapter::ActiveRecord) }
+      end
+    end
+
+    context "using custom values" do
+      context "using :orm setter method" do
+        before do
+          Rolify.orm = "mongoid"
+        end
+
+        subject { Rolify.orm }
+
+        it { should eq("mongoid") }
+        
+        context "on the User class" do
+          before do
+            MUser.rolify
+          end
+
+          subject { MUser }
+          
+          its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+        end
+
+        context "on the Forum class" do
+          before do
+            Forum.resourcify
+          end
+
+          subject { Forum }
+
+          its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+        end
+      end
+      
+      context "using :use_mongoid method" do
+        before do
+          Rolify.use_mongoid
+        end
+
+        subject { Rolify.orm }
+
+        it { should eq("mongoid") }
+        
+        context "on the User class" do
+          before do
+            MUser.rolify
+          end
+
+          subject { MUser }
+          
+          its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+        end
+
+        context "on the Forum class" do
+          before do
+            Forum.resourcify
+          end
+
+          subject { Forum }
+
+          its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+        end
+      end
+    end
+    
+    describe :dynamic_shortcuts do
+      context "using defaults values" do
+        subject { Rolify.dynamic_shortcuts }
+
+        it { should be_false }
+      end
+      
+      context "using custom values" do
+        context "using :dynamic_shortcuts setter method" do
+          before do
+            Rolify.dynamic_shortcuts = true
+          end
+
+          subject { Rolify.dynamic_shortcuts }
+
+          it { should be_true }
+        end
+
+        context "using :use_dynamic_shortcuts method" do
+          before do
+            Rolify.use_dynamic_shortcuts
+          end
+
+          subject { Rolify.dynamic_shortcuts }
+
+          it { should be_true }
+        end
+      end
+    end
+  end
+  
+  describe :configure do
+    before do
+      Rolify.configure do |r|
+        r.dynamic_shortcuts = true
+        r.orm = "mongoid"
+      end
+    end
+    
+    its(:dynamic_shortcuts) { should be_true }
+    its(:orm) { should eq("mongoid") }
+    
+    context "on the User class" do
+      before do
+        MUser.rolify
+      end
+
+      subject { MUser }
+      
+      it { should satisfy { |u| u.include? Rolify::Role }}
+      it { should satisfy { |u| u.singleton_class.include? Rolify::Dynamic } }
+      its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+    end
+
+    context "on the Forum class" do
+      before do
+        Forum.resourcify
+      end
+
+      subject { Forum }
+      
+      it { should satisfy { |u| u.include? Rolify::Resource }}
+      its("adapter.class") { should be(Rolify::Adapter::Mongoid) }
+    end
+  end
+end

data/spec/rolify/custom_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+require "rolify/shared_examples/shared_examples_for_roles"
+require "rolify/shared_examples/shared_examples_for_dynamic"
+
+describe "Using Rolify with custom User and Role class names" do
+  it_behaves_like Rolify::Role do
+    let(:user_class) { Customer }
+    let(:role_class) { Privilege }
+  end
+
+  it_behaves_like Rolify::Dynamic do
+    let(:user_class) { Customer } 
+    let(:role_class) { Privilege }
+  end
+end