mongoid_ability 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f40f0a70a06a2ef26a9e545cd18a940cd46e4be5
-  data.tar.gz: 0f105daba66547732f737fb1928ab7615d2e9162
+  metadata.gz: 75dab60ffb6d4f20fcf4f7eedbf2c9e1768fde5b
+  data.tar.gz: 60f054142c90df34356e269c0cd5209181077da7
 SHA512:
-  metadata.gz: c74b4310a0a87557bd113f71b067116137a3b9f6f09d0804ed3fb4757f6c090887520c2cedaac882c60e96cfbc76ee96e7e29193cf08d32a13952a55c3bd1215
-  data.tar.gz: 999a48cd89887c46366621f781a359208db66cd50fc512aeee4c812c52556d20abf6c4628852a59274fd83c4782f4f46c792b7efe157d03da2a0e73c4c0702e3
+  metadata.gz: f2c5bd37edba18e8ed18a133267810c0f99674c28de0269d5cec2bfc3c2637d2317d84031cf02f3ee3dcf2572f25c61715820420f839ae1b22f5d1fe783cba26
+  data.tar.gz: bc0373e909e72bee1afb5dbbfd0b3715c1e7581baf8e50527fbf859268d20165b3eb2d20b46fcb4cdab9c80642c65c7a42de6e52b565e3c0363a11cc348e184b

data/lib/mongoid_ability/lock.rb

@@ -24,8 +24,8 @@ module MongoidAbility
         scope :for_subject_id, -> subject_id { where(subject_id: subject_id) }
         scope :for_subject, -> subject { where(subject_type: subject.class.model_name, subject_id: subject.id) }
 
-        scope :class_locks, -> { ne(subject_type: nil).where(subject_id: nil) }
-        scope :id_locks, -> { ne(subject_type: nil, subject_id: nil) }
+        scope :class_locks, -> { where(subject_id: nil) }
+        scope :id_locks, -> { ne(subject_id: nil) }
       end
     end
 
@@ -60,5 +60,14 @@ module MongoidAbility
       self.subject_id.present?
     end
 
+    # ---------------------------------------------------------------------
+    
+    def conditions
+      res = { _type: subject_type }
+      res = res.merge(_id: subject_id) if subject_id.present?
+      res = { '$not' => res } if calculated_outcome == false
+      res
+    end
+
   end
 end

data/lib/mongoid_ability/subject.rb

@@ -23,7 +23,7 @@ module MongoidAbility
       end
 
       # ---------------------------------------------------------------------
-      
+
       # override if needed
       # return for example 'MyLock'
       def lock_class_name
@@ -31,7 +31,7 @@ module MongoidAbility
       end
 
       # ---------------------------------------------------------------------
-        
+
       def self_and_ancestors_with_default_locks
         self.ancestors.select{ |a| a.is_a?(Class) && a.respond_to?(:default_locks) }
       end
@@ -41,40 +41,54 @@ module MongoidAbility
       end
 
       # ---------------------------------------------------------------------
-        
+
+      # TODO: obviously this could be cleaner
       def accessible_by ability, action=:read
         cr = self.criteria
 
         return cr unless ability.user.present?
 
-        id_locks = [
-          ability.user,
-          ability.user.roles_relation
-        ].flatten.collect { |owner|
-          owner.locks_relation.for_subject_type(self.to_s).id_locks.for_action(action).to_a
-        }.flatten
-
-        if ability.can?(action, self)
-          cr.nin({
-                         _id: id_locks.map(&:subject_id).select do |subject_id|
-                           subject = self.new
-                           subject.id = subject_id
-                           ability.cannot?(action, subject)
-                         end
-          })
-        else
-          cr.in({
-                        _id: id_locks.map(&:subject_id).select do |subject_id|
-                          subject = self.new
-                          subject.id = subject_id
-                          ability.can?(action, subject)
-                        end
-          })
+        supercls = self.ancestors_with_default_locks.last || self
+        subject_classes = [supercls].concat(supercls.subclasses)
+
+        subject_classes.each do |cls|
+
+          roles_id_locks = ability.user.roles_relation.collect{ |role| role.locks_relation.for_subject_type(cls.to_s).id_locks.for_action(action) }.flatten
+          user_id_locks = ability.user.locks_relation.for_subject_type(cls.to_s).id_locks.for_action(action)
+
+          closed_roles_id_locks = roles_id_locks.to_a.select(&:closed?)
+          open_roles_id_locks = roles_id_locks.to_a.select(&:open?)
+
+          closed_user_id_locks = user_id_locks.to_a.select(&:closed?)
+          open_user_id_locks = user_id_locks.to_a.select(&:open?)
+
+          if ability.can?(action, cls)
+            excluded_ids = []
+
+            id_locks = closed_roles_id_locks.
+              reject{ |cl| open_roles_id_locks.any?{ |ol| ol.subject_id == cl.subject_id } }.
+              reject{ |cl| open_user_id_locks.any?{ |ol| ol.subject_id == cl.subject_id } }
+
+            id_locks += closed_user_id_locks
+            
+            excluded_ids << id_locks.map(&:subject_id)
+
+            cr = cr.or(_type: cls.to_s, :_id.nin => excluded_ids.flatten)
+          else
+            included_ids = []
+
+            id_locks = open_roles_id_locks
+            id_locks += open_user_id_locks
+
+            included_ids << id_locks.map(&:subject_id)
+
+            cr = cr.or(_type: cls.to_s, :_id.in => included_ids.flatten)
+          end
         end
+
+        cr
       end
     end
 
-    # =====================================================================
-
   end
 end

data/lib/mongoid_ability/version.rb

@@ -1,3 +1,3 @@
 module MongoidAbility
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/mongoid_ability/lock_test.rb

@@ -3,6 +3,7 @@ require 'test_helper'
 module MongoidAbility
   describe Lock do
 
+    let(:subject_test) { SubjectTest.new }
     subject { TestLock.new }
     
     # =====================================================================
@@ -51,6 +52,42 @@ module MongoidAbility
       it 'has #id_lock?' do
         subject.must_respond_to :id_lock?
       end
+
+      describe '#criteria' do
+        let(:open_subject_type_lock) {  TestLock.new(subject_type: subject_test.class.to_s, action: :read, outcome: true) }
+        let(:closed_subject_type_lock) {  TestLock.new(subject_type: subject_test.class.to_s, action: :read, outcome: false) }
+
+        let(:open_subject_lock) {  TestLock.new(subject: subject_test, action: :read, outcome: true) }
+        let(:closed_subject_lock) {  TestLock.new(subject: subject_test, action: :read, outcome: false) }
+
+        it 'returns conditions Hash' do
+          open_subject_type_lock.conditions.must_be_kind_of Hash
+          closed_subject_type_lock.conditions.must_be_kind_of Hash
+
+          open_subject_lock.conditions.must_be_kind_of Hash
+          closed_subject_lock.conditions.must_be_kind_of Hash
+        end
+
+        describe 'when open' do
+          it 'includes subject_type' do
+            open_subject_type_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type })
+          end
+
+          it 'includes id' do
+            open_subject_lock.conditions.must_equal({ _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id })
+          end
+        end
+
+        describe 'when closed' do
+          it 'excludes subject_type' do
+            closed_subject_type_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type }})
+          end
+
+          it 'includes id' do
+            closed_subject_lock.conditions.must_equal({ '$not' => { _type: open_subject_type_lock.subject_type, _id: open_subject_lock.subject_id }})
+          end
+        end
+      end
     end
 
   end

data/test/mongoid_ability/subject_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 module MongoidAbility
   describe Subject do
 
-    def default_lock subject_cls, outcome
+    def subject_type_lock subject_cls, outcome
       TestLock.new(subject_type: subject_cls.to_s, action: :read, outcome: outcome)
     end
 
@@ -13,18 +13,19 @@ module MongoidAbility
 
     # ---------------------------------------------------------------------
 
-    subject { TestSubject.new }
+    subject { SubjectTest.new }
 
-    let(:subject_test_1) { TestSubject.create! }
-    let(:subject_test_2) { TestSubject.create! }
+    let(:subject_test_1) { SubjectTestOne.create! }
+    let(:subject_test_2) { SubjectTestTwo.create! }
 
-    let(:subject_super) { TestSubjectSuper.new }
+    # let(:embedded_test_subject_1) { EmbeddedTestSubject.new }
+    # let(:embedded_test_subject_2) { EmbeddedTestSubjectTwo.new }
+    # let(:embedded_test_subject_owner) { EmbeddedTestSubjectOwner.new(embedded_test_subjects: [ embedded_test_subject_1, embedded_test_subject_2 ]) }
 
-    let(:embedded_test_subject_1) { EmbeddedTestSubject.new }
-    let(:embedded_test_subject_2) { EmbeddedTestSubject.new }
-    let(:embedded_test_subject_owner) { EmbeddedTestSubjectOwner.new(embedded_test_subjects: [ embedded_test_subject_1, embedded_test_subject_2 ]) }
+    let(:role_1) { TestRole.new }
+    let(:role_2) { TestRole.new }
 
-    let(:user) { TestUser.new }
+    let(:user) { TestUser.new(roles: [role_1, role_2]) }
     let(:ability) { Ability.new(user) }
 
     # =====================================================================
@@ -53,131 +54,143 @@ module MongoidAbility
 
       describe '.ancestors_with_default_locks' do
         it 'lists ancestors with default locks' do
-          subject.class.ancestors_with_default_locks.must_equal [TestSubjectSuper]
+          subject_test_1.class.ancestors_with_default_locks.must_equal [subject.class]
         end
       end
 
       describe '.self_and_ancestors_with_default_locks' do
         it 'lists self and ancestors with default locks' do
-          subject.class.self_and_ancestors_with_default_locks.must_equal [TestSubject, TestSubjectSuper]
+          subject_test_1.class.self_and_ancestors_with_default_locks.must_equal [subject_test_1.class, subject.class]
         end
       end
 
       # =====================================================================
 
       describe '.accessible_by' do
+        before do
+          subject_test_1
+          subject_test_2
+        end
 
         it 'returns Mongoid::Criteria' do
           subject.class.accessible_by(ability).must_be_kind_of Mongoid::Criteria
-          embedded_test_subject_1.class.accessible_by(ability).must_be_kind_of Mongoid::Criteria
+          # embedded_test_subject_1.class.accessible_by(ability).must_be_kind_of Mongoid::Criteria
         end
 
-        describe 'embedded relations' do
-          it 'returns correct criteria type' do
-            embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).embedded?.must_equal true
-          end
-        end
+        # describe 'embedded relations' do
+        #   it 'returns correct criteria type' do
+        #     embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).embedded?.must_equal true
+        #   end
+        # end
 
         # ---------------------------------------------------------------------
 
         describe 'default locks' do
           describe 'referenced relations' do
             it 'returns everything when open' do
-              subject_test_1
-              subject_test_2
-
-              subject.class.stub(:default_locks, [ default_lock(subject_test_1.class, true) ]) do
+              subject.class.stub(:default_locks, [ subject_type_lock(subject.class, true) ]) do
                 subject.class.accessible_by(ability).must_include subject_test_1
                 subject.class.accessible_by(ability).must_include subject_test_2
               end
             end
 
             it 'returns nothing when closed' do
-              subject.class.stub(:default_locks, [ default_lock(subject_test_1.class, false) ]) do
+              subject.class.stub(:default_locks, [ subject_type_lock(subject.class, false) ]) do
                 subject.class.accessible_by(ability).must_be :empty?
               end
             end
           end
-
-          describe 'embedded relations' do
-            it 'returns everything when open' do
-              subject.class.stub(:default_locks, [ default_lock(embedded_test_subject_1.class, true) ]) do
-                embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_include embedded_test_subject_1
-                embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_include embedded_test_subject_2
-              end
-            end
-
-            it 'returns nothing when closed' do
-              subject.class.stub(:default_locks, [ default_lock(embedded_test_subject_1.class, false) ]) do
-                embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_be :empty?
-              end
-            end
-          end
         end
 
         # ---------------------------------------------------------------------
 
-        describe 'id locks' do
-          describe 'referenced relations' do
-            it 'excludes subject when closed' do
-              user.test_locks = [ subject_lock(subject_test_1, true), subject_lock(subject_test_2, false) ]
+        describe 'subject_type lock' do
+          describe 'on roles' do
+            it 'overrides default lock' do
+              role_1.test_locks = [ subject_type_lock(subject.class, false) ]
+              subject.class.accessible_by(ability).must_be :empty?
+            end
+            it 'takes the most permissive of roles' do
+              role_1.test_locks = [ subject_type_lock(subject.class, false) ]
+              role_2.test_locks = [ subject_type_lock(subject.class, true) ]
               subject.class.accessible_by(ability).must_include subject_test_1
-              subject.class.accessible_by(ability).wont_include subject_test_2
+              subject.class.accessible_by(ability).must_include subject_test_2
             end
           end
 
-          describe 'embedded relations' do
-            it 'excludes subject when closed' do
-              user.test_locks = [ subject_lock(embedded_test_subject_1, true), subject_lock(embedded_test_subject_2, false) ]
-              embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_include embedded_test_subject_1
-              embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).wont_include embedded_test_subject_2
+          describe 'on user' do
+            it 'overrides default lock' do
+              user.test_locks = [ subject_type_lock(subject.class, false) ]
+              subject.class.accessible_by(ability).must_be :empty?
+            end
+            it 'overrides role locks' do
+              role_1.test_locks = [ subject_type_lock(subject.class, false) ]
+              user.test_locks = [ subject_type_lock(subject.class, true) ]
+              subject.class.accessible_by(ability).must_include subject_test_1
+              subject.class.accessible_by(ability).must_include subject_test_2
             end
           end
         end
 
         # ---------------------------------------------------------------------
 
-        describe 'default locks & id locks' do
-          describe 'referenced relations' do
-            describe 'default open' do
-              it 'excludes subject when id lock closed' do
-                subject.class.stub(:default_locks, [ default_lock(subject_test_1.class, true) ]) do
-                  user.test_locks = [ subject_lock(subject_test_2, false) ]
-                  subject.class.accessible_by(ability).must_include subject_test_1
-                  subject.class.accessible_by(ability).wont_include subject_test_2
-                end
+        describe 'subject_id lock' do
+          describe 'on roles' do
+            it 'overrides default lock' do
+              role_1.test_locks = [ subject_lock(subject_test_1, false) ]
+              subject.class.accessible_by(ability).wont_include subject_test_1
+            end
+
+            it 'overrides default negative lock' do
+              subject.class.stub(:default_locks, [ subject_type_lock(subject_test_1.class, false) ]) do
+                role_1.test_locks = [ subject_lock(subject_test_1, true) ]
+                subject.class.accessible_by(ability).must_include subject_test_1
               end
             end
 
-            describe 'default closed' do
-              it 'includes subject when id lock open' do
-                subject.class.stub(:default_locks, [ default_lock(subject_test_1.class, false) ]) do
-                  user.test_locks = [ subject_lock(subject_test_2, true) ]
-                  subject.class.accessible_by(ability).wont_include subject_test_1
-                  subject.class.accessible_by(ability).must_include subject_test_2
-                end
+            it 'overrides subject_type lock' do
+              role_1.test_locks = [ subject_type_lock(subject_test_2.class, false) ]
+              role_2.test_locks = [ subject_lock(subject_test_2, true) ]
+              subject.class.accessible_by(ability).must_include subject_test_2
+            end
+
+            it 'overrides default negative lock' do
+              subject.class.stub(:default_locks, [ subject_type_lock(subject_test_2.class, false) ]) do
+                role_2.test_locks = [ subject_lock(subject_test_2, true) ]
+                subject.class.accessible_by(ability).wont_include subject_test_1
+                subject.class.accessible_by(ability).must_include subject_test_2
               end
             end
+
+            it 'takes the most permissive of roles' do
+              role_1.test_locks = [ subject_lock(subject_test_2, false) ]
+              role_2.test_locks = [ subject_lock(subject_test_2, true) ]
+              subject.class.accessible_by(ability).must_include subject_test_2
+            end
           end
 
-          describe 'embedded relations' do
-            describe 'default open' do
-              it 'excludes subject when id lock closed' do
-                subject.class.stub(:default_locks, [ default_lock(embedded_test_subject_1.class, true) ]) do
-                  user.test_locks = [ subject_lock(embedded_test_subject_2, false) ]
-                  embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_include embedded_test_subject_1
-                  embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).wont_include embedded_test_subject_2
-                end
-              end
+          describe 'on user' do
+            it 'overrides default lock' do
+              user.test_locks = [ subject_lock(subject_test_1, false) ]
+              subject.class.accessible_by(ability).wont_include subject_test_1
+              subject.class.accessible_by(ability).must_include subject_test_2
+            end
+
+            it 'overrides subject_type lock' do
+              user.test_locks = [ subject_type_lock(subject_test_1.class, true), subject_lock(subject_test_1, false) ]
+              subject.class.accessible_by(ability).wont_include subject_test_1
+            end
+
+            it 'overrides role locks' do
+              role_1.test_locks = [ subject_lock(subject_test_2, false) ]
+              user.test_locks = [ subject_lock(subject_test_2, true) ]
+              subject.class.accessible_by(ability).must_include subject_test_2
             end
 
-            describe 'default closed' do
-              it 'includes subject when id lock open' do
-                subject.class.stub(:default_locks, [ default_lock(embedded_test_subject_1.class, false) ]) do
-                  user.test_locks = [ subject_lock(embedded_test_subject_2, true) ]
-                  embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).wont_include embedded_test_subject_1
-                  embedded_test_subject_owner.embedded_test_subjects.accessible_by(ability).must_include embedded_test_subject_2
-                end
+            it 'overrides default negative lock' do
+              subject.class.stub(:default_locks, [ subject_type_lock(subject_test_2.class, false) ]) do
+                user.test_locks = [ subject_lock(subject_test_2, true) ]
+                subject.class.accessible_by(ability).must_include subject_test_2
               end
             end
           end
@@ -187,4 +200,4 @@ module MongoidAbility
     end
   end
 
-end
+end

data/test/test_helper.rb

@@ -71,26 +71,36 @@ end
 
 # ---------------------------------------------------------------------
 
-class TestSubjectSuper
+class SubjectTest
   include Mongoid::Document
   include MongoidAbility::Subject
-end
 
-class TestSubject < TestSubjectSuper
   default_lock :read, true
 end
 
-class EmbeddedTestSubjectOwner
-  include Mongoid::Document
-  include MongoidAbility::Subject
-
-  embeds_many :embedded_test_subjects
+class SubjectTestOne < SubjectTest
 end
 
-class EmbeddedTestSubject < TestSubject
-  embedded_in :embedded_test_subject_owner
+class SubjectTestTwo < SubjectTest
 end
 
+
+
+# class EmbeddedTestSubjectOwner
+#   include Mongoid::Document
+#   include MongoidAbility::Subject
+
+#   embeds_many :embedded_test_subjects
+# end
+
+# class EmbeddedTestSubject < TestSubject
+#   embedded_in :embedded_test_subject_owner
+# end
+
+# class EmbeddedTestSubjectTwo < TestSubject
+#   embedded_in :embedded_test_subject_owner
+# end
+
 # ---------------------------------------------------------------------
   
 class TestAbilityResolverSubject
@@ -114,6 +124,8 @@ end
 class TestAbilitySubject < TestAbilitySubjectSuper1
 end
 
+# ---------------------------------------------------------------------
+  
 class TestRole
   include Mongoid::Document
   include MongoidAbility::Owner

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_ability
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Tomas Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-08 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancancan