zuul 0.2.7 → 0.2.8

data/lib/zuul/context.rb

@@ -1,5 +1,6 @@
 module Zuul
   class Context < Struct.new(:class_name, :id)
+    alias_attribute :klass, :class_name
 
     def self.parse(*args)
       if args.length >= 2
@@ -24,9 +25,22 @@ module Zuul
       !class_name.nil? && id.nil?
     end
 
-    def nil?
+    def global?
       class_name.nil? && id.nil?
     end
+    alias_method :nil?, :global?
+
+    def ==(kontext)
+      class_name == kontext.class_name && id == kontext.id
+    end
+
+    def <=(kontext)
+      kontext.global? || (class_name == kontext.class_name && (kontext.id.nil? || id == kontext.id))
+    end
+    
+    def >=(kontext)
+      kontext <= self
+    end
 
     def type
       return :nil if class_name.nil?

data/lib/zuul/version.rb

@@ -1,3 +1,3 @@
 module Zuul
-  VERSION = '0.2.7'
+  VERSION = '0.2.8'
 end

data/spec/support/models.rb

@@ -1,20 +1,17 @@
 # Default Subject, Role, Permission and Context models
 Object.send(:remove_const, :User) if defined?(User) # we do this to undefine the model and start fresh, without any of the authorization stuff applied by tests
 class User < ActiveRecord::Base
-  attr_accessible :name if ::Zuul
-.should_whitelist?
+  attr_accessible :name if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Role) if defined?(Role)
 class Role < ActiveRecord::Base
-  attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul
-.should_whitelist?
+  attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Permission) if defined?(Permission)
 class Permission < ActiveRecord::Base
-  attr_accessible :name, :slug, :context_type, :context_id if ::Zuul
-.should_whitelist?
+  attr_accessible :name, :slug, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Context) if defined?(Context)
@@ -49,12 +46,12 @@ end
 # Additional models to test scoping
 Object.send(:remove_const, :Level) if defined?(Level)
 class Level < ActiveRecord::Base
-  attr_accessible :name, :slug, :level, :context_type, :context_id
+  attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Ability) if defined?(Ability)
 class Ability < ActiveRecord::Base
-  attr_accessible :name, :slug, :context_type, :context_id
+  attr_accessible :name, :slug, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :AbilityLevel) if defined?(AbilityLevel)
@@ -84,20 +81,17 @@ end
 # Custom named Subject, Role, Permission and Context models
 Object.send(:remove_const, :Soldier) if defined?(Soldier)
 class Soldier < ActiveRecord::Base
-  attr_accessible :name if ::Zuul
-.should_whitelist?
+  attr_accessible :name if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Rank) if defined?(Rank)
 class Rank < ActiveRecord::Base
-  attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul
-.should_whitelist?
+  attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Skill) if defined?(Skill)
 class Skill < ActiveRecord::Base
-  attr_accessible :name, :slug, :context_type, :context_id if ::Zuul
-.should_whitelist?
+  attr_accessible :name, :slug, :context_type, :context_id if ::Zuul.should_whitelist?
 end
 
 Object.send(:remove_const, :Weapon) if defined?(Weapon)
@@ -136,20 +130,17 @@ module ZuulModels
 
   send(:remove_const, :User) if defined?(ZuulModels::User)
   class User < ActiveRecord::Base
-    attr_accessible :name if ::Zuul
-.should_whitelist?
+    attr_accessible :name if ::Zuul.should_whitelist?
   end
 
   send(:remove_const, :Role) if defined?(ZuulModels::Role)
   class Role < ActiveRecord::Base
-    attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul
-.should_whitelist?
+    attr_accessible :name, :slug, :level, :context_type, :context_id if ::Zuul.should_whitelist?
   end
 
   send(:remove_const, :Permission) if defined?(ZuulModels::Permission)
   class Permission < ActiveRecord::Base
-    attr_accessible :name, :slug, :context_type, :context_id if ::Zuul
-.should_whitelist?
+    attr_accessible :name, :slug, :context_type, :context_id if ::Zuul.should_whitelist?
   end
 
   send(:remove_const, :Context) if defined?(ZuulModels::Context)

data/spec/zuul/active_record/permission_role_spec.rb

@@ -77,7 +77,7 @@ describe "Zuul::ActiveRecord::PermissionRole" do
   it "should provide the model with belongs_to associations for permissions and roles" do
     PermissionRole.reflections.keys.should include(:permission)
     PermissionRole.reflections.keys.should include(:role)
-    pu = PermissionRole.create(:permission_id => 1, :use_id => 1)
+    pu = PermissionRole.create(:permission_id => 1, :role_id => 1)
     pu.should respond_to(:permission)
     pu.should respond_to(:role)
   end

data/spec/zuul/active_record/permission_subject_spec.rb

@@ -77,7 +77,7 @@ describe "Zuul::ActiveRecord::PermissionSubject" do
   it "should provide the model with belongs_to associations for permissions and subjects" do
     PermissionUser.reflections.keys.should include(:permission)
     PermissionUser.reflections.keys.should include(:user)
-    pu = PermissionUser.create(:permission_id => 1, :use_id => 1)
+    pu = PermissionUser.create(:permission_id => 1, :user_id => 1)
     pu.should respond_to(:permission)
     pu.should respond_to(:user)
   end

data/spec/zuul/active_record/role_spec.rb

@@ -338,19 +338,19 @@ describe "Zuul::ActiveRecord::Role" do
         nil_permission_role.id.should_not be_nil
         nil_permission_role.context_type.should be_nil
         nil_permission_role.context_id.should be_nil
-        nil_permission_role.permission.should == nil_permission
+        nil_permission_role.permission.id.should == nil_permission.id
         
         class_permission_role = @role.assign_permission(:edit, Context)
         class_permission_role.id.should_not be_nil
         class_permission_role.context_type.should == 'Context'
         class_permission_role.context_id.should be_nil
-        class_permission_role.permission.should == class_permission
+        class_permission_role.permission.id.should == class_permission.id
         
         inst_permission_role = @role.assign_permission(:edit, context)
         inst_permission_role.id.should_not be_nil
         inst_permission_role.context_type.should == 'Context'
         inst_permission_role.context_id.should == context.id
-        inst_permission_role.permission.should == inst_permission
+        inst_permission_role.permission.id.should == inst_permission.id
       end
 
       it "should use the permission object when one is provided" do
@@ -393,15 +393,18 @@ describe "Zuul::ActiveRecord::Role" do
         PermissionRole.where(:role_id => @role.id, :permission_id => permission.id).count.should == 1
       end
 
-      it "should fail and return false if the provided permission is already assigned in the provided context" do
+      it "should return the assigned permission if it is already assigned withinin the provided context" do
         permission = Permission.create(:name => 'Edit', :slug => 'edit')
         context = Context.create(:name => "Test Context")
         @role.assign_permission(permission)
-        @role.assign_permission(permission).should be_false
+        @role.assign_permission(permission).should be_an_instance_of(PermissionRole)
+        PermissionRole.where(:role_id => @role.id, :permission_id => permission.id, :context_type => nil, :context_id => nil).count.should == 1
         @role.assign_permission(permission, Context)
-        @role.assign_permission(permission, Context).should be_false
+        @role.assign_permission(permission, Context).should be_an_instance_of(PermissionRole)
+        PermissionRole.where(:role_id => @role.id, :permission_id => permission.id, :context_type => 'Context', :context_id => nil).count.should == 1
         @role.assign_permission(permission, context)
-        @role.assign_permission(permission, context).should be_false
+        @role.assign_permission(permission, context).should be_an_instance_of(PermissionRole)
+        PermissionRole.where(:role_id => @role.id, :permission_id => permission.id, :context_type => 'Context', :context_id => context.id).count.should == 1
       end
       
       context "when forcing context" do

data/spec/zuul/active_record/role_subject_spec.rb

@@ -77,7 +77,7 @@ describe "Zuul::ActiveRecord::RoleSubject" do
   it "should provide the model with belongs_to associations for roles and subjects" do
     RoleUser.reflections.keys.should include(:role)
     RoleUser.reflections.keys.should include(:user)
-    ru = RoleUser.create(:role_id => 1, :use_id => 1)
+    ru = RoleUser.create(:role_id => 1, :user_id => 1)
     ru.should respond_to(:role)
     ru.should respond_to(:user)
   end

data/spec/zuul/active_record/subject_spec.rb

@@ -150,15 +150,18 @@ describe "Zuul::ActiveRecord::Subject" do
         RoleUser.where(:user_id => @user.id, :role_id => role.id).count.should == 1
       end
 
-      it "should fail and return false if the provided role is already assigned in the provided context" do
+      it "should return the assigned role if it is already assigned within the provided context" do
         role = Role.create(:name => 'Admin', :slug => 'admin', :level => 100)
         context = Context.create(:name => "Test Context")
         @user.assign_role(role)
-        @user.assign_role(role).should be_false
+        @user.assign_role(role).should be_an_instance_of(RoleUser)
+        RoleUser.where(:user_id => @user.id, :role_id => role.id, :context_type => nil, :context_id => nil).count.should == 1
         @user.assign_role(role, Context)
-        @user.assign_role(role, Context).should be_false
+        @user.assign_role(role, Context).should be_an_instance_of(RoleUser)
+        RoleUser.where(:user_id => @user.id, :role_id => role.id, :context_type => 'Context', :context_id => nil).count.should == 1
         @user.assign_role(role, context)
-        @user.assign_role(role, context).should be_false
+        @user.assign_role(role, context).should be_an_instance_of(RoleUser)
+        RoleUser.where(:user_id => @user.id, :role_id => role.id, :context_type => 'Context', :context_id => context.id).count.should == 1
       end
 
       context "when forcing context" do
@@ -847,15 +850,18 @@ describe "Zuul::ActiveRecord::Subject" do
         PermissionUser.where(:user_id => @user.id, :permission_id => permission.id).count.should == 1
       end
 
-      it "should fail and return false if the provided permission is already assigned in the provided context" do
+      it "should return the assigned permission if it is already assigned within the provided context" do 
         permission = Permission.create(:name => 'Edit', :slug => 'edit')
         context = Context.create(:name => "Test Context")
         @user.assign_permission(permission)
-        @user.assign_permission(permission).should be_false
+        @user.assign_permission(permission).should be_an_instance_of(PermissionUser)
+        PermissionUser.where(:user_id => @user.id, :permission_id => permission.id, :context_type => nil, :context_id => nil).count.should == 1
         @user.assign_permission(permission, Context)
-        @user.assign_permission(permission, Context).should be_false
+        @user.assign_permission(permission, Context).should be_an_instance_of(PermissionUser)
+        PermissionUser.where(:user_id => @user.id, :permission_id => permission.id, :context_type => 'Context', :context_id => nil).count.should == 1
         @user.assign_permission(permission, context)
-        @user.assign_permission(permission, context).should be_false
+        @user.assign_permission(permission, context).should be_an_instance_of(PermissionUser)
+        PermissionUser.where(:user_id => @user.id, :permission_id => permission.id, :context_type => 'Context', :context_id => context.id).count.should == 1
       end
 
       context "when forcing context" do

data/spec/zuul/active_record_spec.rb

@@ -159,9 +159,9 @@ describe "Zuul::ActiveRecord" do
       Role.ancestors.include?(Zuul::ActiveRecord::Role).should be_true
     end
     
-    it "should extend the model with Zuul::ActiveRecord::ContextMethods" do
+    it "should extend the model with Zuul::ActiveRecord::ContextAccessors" do
       Role.acts_as_authorization_role
-      Role.ancestors.include?(Zuul::ActiveRecord::ContextMethods).should be_true
+      Role.ancestors.include?(Zuul::ActiveRecord::ContextAccessors).should be_true
     end
     
     it "should extend the model with Zuul::ActiveRecord::Role::PermissionMethods if permissions enabled" do
@@ -181,9 +181,9 @@ describe "Zuul::ActiveRecord" do
       Permission.ancestors.include?(Zuul::ActiveRecord::Permission).should be_true
     end
     
-    it "should extend the model with Zuul::ActiveRecord::ContextMethods" do
+    it "should extend the model with Zuul::ActiveRecord::ContextAccessors" do
       Permission.acts_as_authorization_permission
-      Permission.ancestors.include?(Zuul::ActiveRecord::ContextMethods).should be_true
+      Permission.ancestors.include?(Zuul::ActiveRecord::ContextAccessors).should be_true
     end
   end
 

data/spec/zuul/context_spec.rb

@@ -2,6 +2,11 @@ require 'spec_helper'
 
 describe "Zuul::Context" do
 
+  it "should alias :klass to :class_name" do
+    context = Zuul::Context.parse(Context)
+    expect(context.klass).to eql(context.class_name)
+  end
+
   describe "parse" do
     it "should allow passing nil" do
       expect { Zuul::Context.parse(nil) }.to_not raise_exception
@@ -96,21 +101,363 @@ describe "Zuul::Context" do
     end
   end
 
-  describe "#nil?" do
+  describe "#global?" do
     it "should return true for a nil context" do
-      Zuul::Context.new.nil?.should be_true
+      Zuul::Context.new.global?.should be_true
     end
 
     it "should return false for a class context" do
-      Zuul::Context.new('Context', nil).nil?.should be_false
+      Zuul::Context.new('Context', nil).global?.should be_false
     end
 
     it "should return false for an instance context" do
+      obj = Context.create(:name => "Test Context")
+      Zuul::Context.new('Context', obj.id).global?.should be_false
+    end
+
+    it "should be aliased to #nil? for deprecation and compatibility" do
+      Zuul::Context.new.nil?.should be_true
+      Zuul::Context.new('Context', nil).nil?.should be_false
       obj = Context.create(:name => "Test Context")
       Zuul::Context.new('Context', obj.id).nil?.should be_false
     end
   end
 
+  describe "#==" do
+    it "should return true if the classes and ids are equal" do
+      obj = Context.create(:name => "Test Context")
+      
+      Zuul::Context.new.should == Zuul::Context.new
+      Zuul::Context.new('Context', nil).should == Zuul::Context.new('Context', nil)
+      Zuul::Context.new('Context', obj.id).should == Zuul::Context.new('Context', obj.id)
+    end
+
+    it "should return false if the classes are not equal" do
+      obj = Context.create(:name => "Test Context")
+      
+      Zuul::Context.new.should_not == Zuul::Context.new('Context', nil)
+      Zuul::Context.new('Context', nil).should_not == Zuul::Context.new('OtherContext', nil)
+    end
+
+    it "should return false if the ids are not equal" do
+      obj1 = Context.create(:name => "Test Context One")
+      obj2 = Context.create(:name => "Test Context Two")
+      
+      Zuul::Context.new('Context', obj1.id).should_not == Zuul::Context.new('Context', nil)
+      Zuul::Context.new('Context', obj1.id).should_not == Zuul::Context.new('Context', obj2.id)
+    end
+  end
+
+  describe "#<=" do
+    context "with a global context" do
+      let(:context) { Zuul::Context.new }
+      
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return true" do
+          expect(context <= kontext).to be_true
+        end
+      end
+      
+      context "when compared to a class context" do
+        let(:kontext) { Zuul::Context.new('Context') }
+        
+        it "should return false" do
+          expect(context <= kontext).to be_false
+        end
+      end
+      
+      context "when compared to an instance context" do
+        let(:kontext) do
+          obj = Context.create(:name => "Test Context")
+          Zuul::Context.new('Context', obj.id)
+        end
+        
+        it "should return false" do
+          expect(context <= kontext).to be_false
+        end
+      end
+    end
+    
+    context "with a class context" do
+      let(:context) { Zuul::Context.new('Context') }
+      
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return true" do
+          expect(context <= kontext).to be_true
+        end
+      end
+      
+      context "when compared to a class context" do
+        context "with the same class" do
+          let(:kontext) { Zuul::Context.new('Context') }
+          
+          it "should return true" do
+            expect(context <= kontext).to be_true
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) { Zuul::Context.new('OtherContext') }
+          
+          it "should return false" do
+            expect(context <= kontext).to be_false
+          end
+        end
+      end
+
+      context "when compared to an instance context" do
+        context "with the same class" do
+          let(:kontext) do
+            obj = Context.create(:name => "Test Context")
+            Zuul::Context.new('Context', obj.id)
+          end
+          
+          it "should return false" do
+            expect(context <= kontext).to be_false
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) do
+            obj = ZuulModels::Context.create(:name => "Test Context")
+            Zuul::Context.new('OtherContext', obj.id)
+          end
+          
+          it "should return false" do
+            expect(context <= kontext).to be_false
+          end
+        end
+      end
+    end
+    
+    context "with an instance context" do
+      let(:obj) { Context.create(:name => "Test Context") }
+      let(:context) do
+        Zuul::Context.new('Context', obj.id)
+      end
+
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return true" do
+          expect(context <= kontext).to be_true
+        end
+      end
+      
+      context "when compared to a class context" do
+        context "with the same class" do
+          let(:kontext) { Zuul::Context.new('Context') }
+          
+          it "should return true" do
+            expect(context <= kontext).to be_true
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) { Zuul::Context.new('OtherContext') }
+          
+          it "should return false" do
+            expect(context <= kontext).to be_false
+          end
+        end
+      end
+      
+      context "when compared to an instance context" do
+        context "with the same class" do
+          context "with the same id" do
+            let(:kontext) do
+              Zuul::Context.new('Context', obj.id)
+            end
+            
+            it "should return true" do
+              expect(context <= kontext).to be_true
+            end
+          end
+          
+          context "with a different id" do
+            let(:kontext) do
+              other_obj = Context.create(:name => "Other Context")
+              Zuul::Context.new('Context', other_obj.id)
+            end
+
+            it "should return false" do
+              expect(context <= kontext).to be_false
+            end
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) do
+            Zuul::Context.new('OtherContext', obj.id)
+          end
+          
+          it "should return false" do
+            expect(context <= kontext).to be_false
+          end
+        end
+      end
+    end
+  end
+
+  describe "#>=" do
+    context "with a global context" do
+      let(:context) { Zuul::Context.new }
+      
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return true" do
+          expect(context >= kontext).to be_true
+        end
+      end
+      
+      context "when compared to a class context" do
+        let(:kontext) { Zuul::Context.new('Context') }
+        
+        it "should return true" do
+          expect(context >= kontext).to be_true
+        end
+      end
+      
+      context "when compared to an instance context" do
+        let(:kontext) do
+          obj = Context.create(:name => "Test Context")
+          Zuul::Context.new('Context', obj.id)
+        end
+        
+        it "should return true" do
+          expect(context >= kontext).to be_true
+        end
+      end
+    end
+    
+    context "with a class context" do
+      let(:context) { Zuul::Context.new('Context') }
+      
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return false" do
+          expect(context >= kontext).to be_false
+        end
+      end
+      
+      context "when compared to a class context" do
+        context "with the same class" do
+          let(:kontext) { Zuul::Context.new('Context') }
+          
+          it "should return true" do
+            expect(context >= kontext).to be_true
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) { Zuul::Context.new('OtherContext') }
+          
+          it "should return false" do
+            expect(context >= kontext).to be_false
+          end
+        end
+      end
+
+      context "when compared to an instance context" do
+        context "with the same class" do
+          let(:kontext) do
+            obj = Context.create(:name => "Test Context")
+            Zuul::Context.new('Context', obj.id)
+          end
+          
+          it "should return true" do
+            expect(context >= kontext).to be_true
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) do
+            obj = ZuulModels::Context.create(:name => "Test Context")
+            Zuul::Context.new('OtherContext', obj.id)
+          end
+          
+          it "should return false" do
+            expect(context >= kontext).to be_false
+          end
+        end
+      end
+    end
+    
+    context "with an instance context" do
+      let(:obj) { Context.create(:name => "Test Context") }
+      let(:context) do
+        Zuul::Context.new('Context', obj.id)
+      end
+
+      context "when compared a global context" do
+        let(:kontext) { Zuul::Context.new }
+        
+        it "should return false" do
+          expect(context >= kontext).to be_false
+        end
+      end
+      
+      context "when compared to a class context" do
+        context "with the same class" do
+          let(:kontext) { Zuul::Context.new('Context') }
+          
+          it "should return false" do
+            expect(context >= kontext).to be_false
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) { Zuul::Context.new('OtherContext') }
+          
+          it "should return false" do
+            expect(context >= kontext).to be_false
+          end
+        end
+      end
+      
+      context "when compared to an instance context" do
+        context "with the same class" do
+          context "with the same id" do
+            let(:kontext) do
+              Zuul::Context.new('Context', obj.id)
+            end
+            
+            it "should return true" do
+              expect(context >= kontext).to be_true
+            end
+          end
+          
+          context "with a different id" do
+            let(:kontext) do
+              other_obj = Context.create(:name => "Other Context")
+              Zuul::Context.new('Context', other_obj.id)
+            end
+
+            it "should return false" do
+              expect(context >= kontext).to be_false
+            end
+          end
+        end
+        
+        context "with a different class" do
+          let(:kontext) do
+            Zuul::Context.new('OtherContext', obj.id)
+          end
+          
+          it "should return false" do
+            expect(context >= kontext).to be_false
+          end
+        end
+      end
+    end
+  end
+
   describe "#type" do
     it "should return :nil for a nil context" do
       Zuul::Context.new.type.should == :nil