scoped_rolify 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02c456aa8ca494528222680ebc0024fc8069a91b
-  data.tar.gz: afe192eba189a99fec5f5eed531bb46e137e8c21
+  metadata.gz: 6ccae7235a31e93ee0b08d01aa8f6e8b15289389
+  data.tar.gz: 2e9e9177bf449409e77178e480fc7f6a3808d222
 SHA512:
-  metadata.gz: cfb764ac9b475af72a8361aebcf9cb1b2ea416187dc70eceec89e691763ac9324a3b5d13c398ee9b233e4569cf732327d9cbb5c97e013486931d27559fa818d5
-  data.tar.gz: ad768d2fc9a2f853be116476ec50381225fcef6834789f0962cd8196d1a797ffb60b2d5451af7a3dbbd732fc1dc8642e03edd41f34f7c5ffa8611819a7d0bf7a
+  metadata.gz: ddb035951cee915f2c3dc380818885b82c1d34fab18746ae375e37a9a20bbfb1f086fd97f092df2e2696cfcd249526af0fd1d4dc1b132ef14bee05200c09888f
+  data.tar.gz: 158e81b64ab7521155e2a751b5028053e531b327837ee7d12b4273a92dc66647b2737c4db330a0695532e4b10a02a3e8a55c75fe450ecd4eefa5dfae2ebc9437

data/.ruby-version

@@ -1 +1 @@
-2.0.0-p353
+ruby-2.0.0-p451

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+### VERSION 0.0.5
+
+* bug fix
+
+* enhancements
+  * add notion of root_resource
+
+* backwards incompatible changes
+
+* deprecations
+
+* roadmap
+  * refactoring on root resource 
+
 ### VERSION 0.0.4
 
 * bug fix

data/README.md

@@ -61,6 +61,71 @@ You can't play with none persisted object
 
 Method ```with_any_scoped_role``` return an ```ActiveRecord::Relation``` of all users with all roles asked for one resource
 
+## Root Resource
+
+In some case you can add right on child resource instead of parent resource, the problem is you haven't access directly to objects throught Parent resource, for exemple
+
+You grant user on specifc Forum, user.add_role(:moderator, Forum.first) the Forum have one Category, if you want get all moderators of this Category you can't. This modification make this possible.
+
+    moderator_john = User.new
+    moderator_jane = User.new
+
+    geek_world = Category.new
+
+    geek_forum = Forum.new
+    nerd_forum = Forum.new
+
+    class Forum < ActiveRecord::Base
+      belongs_to :category
+
+      def root_resource
+        :category
+      end
+    end
+
+    class Category < ActiveRecord::Base
+      has_many :forums
+    end
+
+    geek_world.forums << geek_forum
+    geek_world.forums << nerd_forum
+
+    moderator_john.add_role(:moderator, nerd_forum)
+    moderator_jane.add_role(:moderator, geek_forum)
+
+For grab all moderators of this Category
+
+    User.with_scoped_role :moderator, geek_world, root=true
+
+## Roadmap
+
+Refactoring on root resource API
+
+Change
+
+    User.with_scoped_role :moderator, geek_world, root=true
+
+to
+
+    User.with_scoped_role :moderator, geek_world, scope: :forum
+
+And change
+
+    class Forum < ActiveRecord::Base
+      belongs_to :category
+
+      def root_resource
+        :category
+      end
+    end
+    
+to
+
+    class Forum < ActiveRecord::Base
+      belongs_to :category
+      scoped_roles belongs_to: :category 
+    end
+
 ## Contributing
 
 1. Fork it ( http://github.com/<my-github-username>/scoped_rolify/fork )

data/lib/scoped_rolify/finders.rb

@@ -1,26 +1,34 @@
 module Rolify
   module Finders
 
-    def with_scoped_role role_name, resource
+    def with_scoped_role role_name, resource, root_only=false
       ScopedRolify::Policy.new(self, resource).check_persisted!
-      self.joins(:roles).where(rolify_constraints(role_name, resource))
+      self.joins(:roles).where(rolify_constraints(role_name, resource, root_only))
     end
 
-    def with_any_scoped_role role_names, resource
+    def with_any_scoped_role role_names, resource, root_only=false
       ScopedRolify::Policy.new(self, resource).check_persisted!
-      self.joins(:roles).where(rolify_constraints(role_names, resource))
+      self.joins(:roles).where(rolify_constraints(role_names, resource, root_only))
     end
 
-    def rolify_constraints role_names, resource
+    def rolify_constraints role_names, resource, root_only=false
       raise 'You should give somes role' if role_names.nil? or (role_names||[]).empty?
+      
       ScopedRolify::Policy.new(self, resource).check_persisted!
+            
       table = Arel::Table.new(:roles)
+
       [].tap do |_constraints|
         Array.wrap(role_names).each do |name|
           _constraints << [].tap do |_constraint|
             _constraint << table[:name].eq(name)
-            _constraint << table[:resource_type].eq(resource.class.name)
-            _constraint << table[:resource_id].eq(resource.id)
+            if root_only
+              _constraint << table[:root_resource_type].eq(resource.class.name)
+              _constraint << table[:root_resource_id].eq(resource.id)
+            else
+              _constraint << table[:resource_type].eq(resource.class.name)
+              _constraint << table[:resource_id].eq(resource.id)
+            end
           end.reduce(:and)
         end
       end.reduce(:or)

data/lib/scoped_rolify/policy.rb

@@ -8,7 +8,7 @@ module ScopedRolify
 
     def check_persisted!
       check!
-      raise PersitenceError, "You should ask on persisted resource" unless self.resource.persisted?
+      raise PersistenceError, "You should ask on persisted resource" unless self.resource.persisted?
     end
 
   end

data/lib/scoped_rolify/role.rb

@@ -12,25 +12,59 @@ module Rolify
     end
 
     def has_role?(role_name, resource = nil)
+      root_resource = resource.respond_to?(:root_resource) ? resource.send(resource.root_resource) : nil
       if self.new_record?
-        self.roles.detect { |r| r.name.to_s == role_name.to_s && (r.resource == resource || resource.nil?) }
+        self.roles.detect { |r| r.name.to_s == role_name.to_s && (r.resource == resource || resource.nil?) && (r.root_resource == root_resource || root_resource.nil?) }
       else
-        self.class.adapter.where(self.roles, :name => role_name, :resource => resource)
+        self.class.adapter.where(self.roles, name: role_name, resource: resource, root_resource: root_resource)
       end.present?
     end
 
     private
 
     def add_resourced_role(role_name, resource)
+      root_resource = resource.respond_to?(:root_resource) ? resource.send(resource.root_resource) : nil
       if self.new_record?
-        self.class.adapter.role_class.new(name: role_name, resource: resource).tap do |role|
+        role = self.class.adapter.role_class.new(name: role_name, resource: resource, root_resource: root_resource).tap do |role|
           self.roles << role
           if Rolify.dynamic_shortcuts and !self.respond_to?("is_#{role_name}?".to_sym)
             self.class.define_dynamic_method(role_name, resource)
           end
         end
       else
+        role = add_role_with_root(role_name, resource, root_resource)
+      end
+      add_role_to_resource(role)
+      load_dynamic_shortcuts(role_name, resource)
+      role
+    end
+
+    def load_dynamic_shortcuts(role_name, resource)
+      if Rolify.dynamic_shortcuts and !self.respond_to?("is_#{role_name}?".to_sym)
+        self.class.define_dynamic_method(role_name, resource)
+      end
+    end
+
+    def add_role_to_resource(role)
+      self.roles << role unless self.roles.include?(role)
+    end
+
+    def add_role_with_root(role_name, resource, root_resource)
+      unless root_resource
         add_role(role_name, resource)
+      else
+        conditions = {
+          name: role_name.to_s,
+          resource_type: resource.class.name,
+          resource_id: resource.id,
+        }
+        if root_resource
+          conditions.merge!({ root_resource_type: (root_resource.is_a?(Class) ? root_resource.to_s : root_resource.class.name) })
+          unless root_resource.is_a?(Class) # Useless for the moment (Already false)
+            conditions.merge!({ root_resource_id: root_resource.id })
+          end
+        end
+        self.class.adapter.role_class.where(conditions).first_or_create
       end
     end
 

data/lib/scoped_rolify/version.rb

@@ -1,3 +1,3 @@
 module ScopedRolify
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/spec/scoped_rolify/finders_spec.rb

@@ -1,28 +1,48 @@
 require 'spec_helper'
 
 describe Rolify::Finders do
-  let(:resource) { Forum.first }
+  let(:resource) { Forum.where(name: 'forum 1').first }
   let(:admin)    { User.where(login: 'admin').first }
 
   before { admin.add_role(:admin, resource) }
 
-  subject { User }
-
-  it { expect { subject.with_scoped_role(:admin, Forum) }.to raise_error InstanceResourceError }
-  it { expect { subject.with_scoped_role(:admin, resource) }.to_not raise_error }
+  it { expect { User.with_scoped_role(:admin, Forum) }.to raise_error InstanceResourceError }
+  it { expect { User.with_scoped_role(:admin, resource) }.to_not raise_error }
 
   context 'regular way' do
-    it { subject.with_scoped_role(:admin, resource).should eq([admin]) }
+    it { User.with_scoped_role(:admin, resource).should eq([admin]) }
   end
 
   context '#with_any_scoped_role' do
-    let(:moderator) { subject.where(login: 'moderator').first }
+    let(:moderator) { User.where(login: 'moderator').first }
     before { moderator.add_role(:moderator, resource) }
     it do
-      expect(subject.with_any_scoped_role([:admin, :moderator], resource)).to be_a(ActiveRecord::Relation)
+      expect(User.with_any_scoped_role([:admin, :moderator], resource)).to be_a(ActiveRecord::Relation)
     end
     it do
-      expect(subject.with_any_scoped_role([:admin, :moderator], resource).to_a).to eq([admin, moderator])
+      expect(User.with_any_scoped_role([:admin, :moderator], resource).to_a).to eq([admin, moderator])
+    end
+  end
+
+  context 'with root resource' do
+    let(:root_resource)    { Category.where(name: 'category 1').first }
+    let(:another_resource) { Forum.where(name: 'forum 2').first }
+    let(:super_admin)      { User.where(login: 'super admin').first }
+    let(:moderator)        { User.where(login: 'moderator').first }
+
+    before do
+      root_resource.forums << resource
+      root_resource.forums << another_resource
+    end
+
+    context 'add role to user' do
+      before do
+        super_admin.add_scope_role(:super_admin, resource)
+        moderator.add_scope_role(:super_admin, another_resource)
+      end
+
+      it('should retreive super_admin') { expect(User.with_scoped_role(:super_admin, resource).to_a).to eq([super_admin]) }
+      it('should retreive all user for Category') { expect(User.with_scoped_role(:super_admin, root_resource, true).to_a).to eq([super_admin, moderator]) }
     end
   end
 end

data/spec/scoped_rolify/role_spec.rb

@@ -17,6 +17,7 @@ describe Rolify::Role do
 
     it { expect { subject.add_scope_role(:admin, resource) }.to_not raise_error }
     it { should have_role :admin, resource }
+    it { expect(User.with_scoped_role(:admin, resource).to_a).to eq([user]) }
   end
 
   context 'new record way' do
@@ -33,5 +34,38 @@ describe Rolify::Role do
     end
   end
 
-end
+  context 'with root resource' do
+    context 'persisted way' do
+      let(:root_resource) { Category.first }
 
+      before { root_resource.forums << resource }
+
+      context 'add role to user' do
+        before { subject.add_scope_role(:admin, resource) }
+        it('should retreive user') do
+          expect(
+            User.joins(:roles).where(
+              Role.where(name: :admin, resource_type: 'Forum', resource_id: resource.id,
+                root_resource_type: 'Category', root_resource_id: root_resource.id).arel.constraints.first
+            ).to_a
+          ).to eq([subject])
+        end
+      end
+    end
+
+    context 'unpersisted way' do
+      let(:root_resource) { Category.new(name: 'UnCategoized') }
+      let(:resource)      { Forum.new(name: 'forum 42') }
+      let(:user)          { User.new(login: 'John Doe') }
+
+      before { root_resource.forums << resource }
+
+      it { expect(root_resource.forums).to eq([resource]) }
+
+      context 'add role to user' do
+        before { user.add_scope_role(:admin, resource) }
+        it { should have_role :admin, resource }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,9 +10,14 @@ Coveralls.wear!
 ENV['ADAPTER'] ||= 'active_record'
 
 load File.dirname(__FILE__) + "/support/adapters/#{ENV['ADAPTER']}.rb"
-load File.dirname(__FILE__) + '/support/data.rb'
 
-RSpec.configure do |c|
-  c.run_all_when_everything_filtered = true
+RSpec.configure do |config|
+  config.filter_run focused: true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:each) do
+    [ User, Role, Forum, Category].each &:destroy_all
+    load File.dirname(__FILE__) + '/support/data.rb'
+  end
 end
 

data/spec/support/adapters/active_record.rb

@@ -13,11 +13,20 @@ end
 class Role < ActiveRecord::Base
   has_and_belongs_to_many :users, join_table: :users_roles
   belongs_to :resource, polymorphic: true
+  belongs_to :root_resource, polymorphic: true
 
   extend Rolify::Adapter::Scopes
 end
 
-# Resources classes
 class Forum < ActiveRecord::Base
-  #resourcify done during specs setup to be able to use custom user classes
+  belongs_to :category
+
+  def root_resource
+    :category
+  end
+end
+
+# Resources classes
+class Category < ActiveRecord::Base
+  has_many :forums
 end

data/spec/support/data.rb

@@ -1,10 +1,6 @@
-# Users
-User.destroy_all
 User.create login: 'admin'
+User.create login: 'super admin'
 User.create login: 'moderator'
-
-# Roles
-Role.destroy_all
-
-# Resources
 Forum.create name: 'forum 1'
+Forum.create name: 'forum 2'
+Category.create name: 'category 1'

data/spec/support/schema.rb

@@ -8,6 +8,7 @@ ActiveRecord::Schema.define do
   create_table(:roles) do |t|
     t.string :name
     t.references :resource, polymorphic: true
+    t.references :root_resource, polymorphic: true
     t.timestamps
   end
 
@@ -18,6 +19,10 @@ ActiveRecord::Schema.define do
 
   create_table(:forums) do |t|
     t.string :name
+    t.integer :category_id
   end
 
+  create_table(:categories) do |t|
+    t.string :name
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoped_rolify
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Joel AZEMAR
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-11 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rolify
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: This is a monkey patch of rolify