mongoid_ability 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0c87d76d294916f069dcdb8a809d9870b1c87a6
-  data.tar.gz: b130d99ea2c2e54ecfd341ce7ccb880144e4399a
+  metadata.gz: 5b22befcca304fbace4cd22f72704b7d5a109a0b
+  data.tar.gz: 56a19a326bdb60d7d462558c51cd0d7196146d8b
 SHA512:
-  metadata.gz: 7d097c614650c1898fee81b49fd967e8bc7f1f2790d3b306ba07a59079b7533d27a79fec4a02b55cc68ab3ab7399e715bbc330f6fd5169f740d6cfc7815ba8ef
-  data.tar.gz: 023453a517e10711cafc17a6a4efbe7ff4a0ead1dd90b820c7cfa5ae493badc2b69e98d26acded7a297ca2bc1d854cedaf0059dbfc7f7a4fdc9b330629b59558
+  metadata.gz: 740466111f499e95e981197abc5567740c7ecb829126a863bf6720cddadb5f4b9a75ad9fc851f93bfecb8e90e55ce73a40b20ee8d7741b893412270a7ac71c3b
+  data.tar.gz: 83f00db0cdb31b4f1ebd024c40f5b1390059a0b686119bcf7e27d97a081f4e5d7208286920cf929b55253e73450182201133c63c1dcf882bc10b4ca24e2ab35b

data/lib/mongoid_ability/lock.rb

@@ -45,7 +45,7 @@ module MongoidAbility
       return calculated_outcome unless owner.present?
       cloned_owner = owner.clone
       cloned_owner.locks_relation = cloned_owner.locks_relation - [self]
-      MongoidAbility::Ability.new(cloned_owner).can? action, (id_lock? ? subject : subject_class)
+      MongoidAbility::Ability.new(cloned_owner).can? action, (subject.present? ? subject : subject_class)
     end
 
     # ---------------------------------------------------------------------

data/lib/mongoid_ability/owner.rb

@@ -38,6 +38,12 @@ module MongoidAbility
       @ability ||= MongoidAbility::Ability.new(self)
     end
 
+    # ---------------------------------------------------------------------
+
+    def has_lock? lock
+      locks_relation.where(action: lock.action, subject_type: lock.subject_type, subject_id: lock.subject_id.presence).exists?
+    end
+
     private # =============================================================
 
     def cleanup_locks

data/lib/mongoid_ability/subject.rb

@@ -7,8 +7,6 @@ module MongoidAbility
       end
     end
 
-    # ---------------------------------------------------------------------
-
     module ClassMethods
       def default_locks
         @default_locks ||= []
@@ -19,15 +17,25 @@ module MongoidAbility
       end
 
       def default_lock lock_cls, action, outcome, attrs={}
+        unless is_root_class?
+          unless root_class.has_default_lock_for_action?(action)
+            raise StandardError, "action is not defined on root class (#{root_class})"
+          end
+        end
+
         lock = lock_cls.new( { subject_type: self.to_s, action: action, outcome: outcome }.merge(attrs))
 
-        if existing_lock = default_locks.detect{ |l| l.action.to_s == lock.action.to_s }
+        # remove any existing locks
+        if existing_lock = default_locks.detect{ |l| l.action == lock.action }
           default_locks.delete(existing_lock)
         end
 
+        # add new lock
         default_locks.push lock
       end
 
+      # ---------------------------------------------------------------------
+
       def self_and_ancestors_with_default_locks
         ancestors.select { |a| a.is_a?(Class) && a.respond_to?(:default_locks) }
       end
@@ -36,6 +44,26 @@ module MongoidAbility
         self_and_ancestors_with_default_locks - [self]
       end
 
+      def is_root_class?
+        root_class == self
+      end
+
+      def root_class
+        self_and_ancestors_with_default_locks.last
+      end
+
+      # ---------------------------------------------------------------------
+
+      def default_lock_for_action action
+        default_locks.detect{ |lock| lock.action == action.to_sym }
+      end
+
+      def has_default_lock_for_action? action
+        default_lock_for_action(action).present?
+      end
+
+      # ---------------------------------------------------------------------
+
       def accessible_by ability, action=:read, options={}
         AccessibleQueryBuilder.call(self, ability, action, options)
       end

data/lib/mongoid_ability/version.rb

@@ -1,3 +1,3 @@
 module MongoidAbility
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/test/mongoid_ability/lock_test.rb

@@ -6,6 +6,11 @@ module MongoidAbility
     subject { MyLock.new }
     let(:my_subject) { MySubject.new }
     let(:inherited_lock) { MyLock1.new }
+    # ---------------------------------------------------------------------
+
+    before do
+      MySubject.default_locks = [ MyLock.new(action: :read, outcome: true), MyLock.new(action: :update, outcome: false) ]
+    end
 
     # ---------------------------------------------------------------------
 
@@ -54,12 +59,13 @@ module MongoidAbility
       let(:subject_type_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
       let(:subject_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
       let(:owner) { MyOwner.new(my_locks: [subject_type_lock, subject_lock]) }
-      let(:ability) { Ability.new(owner) }
 
-      before { ability } # initialize owner
+      before do
+        @ability = Ability.new(owner) # initialize owner
+      end
 
       it 'does not affect calculated_outcome' do
-        ability.can?(:read, my_subject).must_equal true
+        @ability.can?(:read, my_subject).must_equal true
       end
 
       it 'returns calculated_outcome without this lock' do
@@ -76,11 +82,11 @@ module MongoidAbility
     # ---------------------------------------------------------------------
 
     describe '#criteria' do
-      let(:open_subject_type_lock) {  MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
-      let(:closed_subject_type_lock) {  MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+      let(:open_subject_type_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
+      let(:closed_subject_type_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
 
-      let(:open_subject_lock) {  MyLock.new(subject: my_subject, action: :read, outcome: true) }
-      let(:closed_subject_lock) {  MyLock.new(subject: my_subject, action: :read, outcome: false) }
+      let(:open_subject_lock) { MyLock.new(subject: my_subject, action: :read, outcome: true) }
+      let(:closed_subject_lock) { MyLock.new(subject: my_subject, action: :read, outcome: false) }
 
       it 'returns conditions Hash' do
         open_subject_type_lock.conditions.must_be_kind_of Hash

data/test/mongoid_ability/owner_test.rb

@@ -22,5 +22,25 @@ module MongoidAbility
         it { subject.locks_relation.metadata[:name].must_equal :my_locks }
       end
     end
+
+    describe '#has_lock?' do
+      let(:subject_type_lock) { MyLock.new(action: :read, subject_type: MySubject) }
+      let(:subject_lock) { MyLock.new(action: :read, subject: MySubject.new) }
+      let(:other_lock) { MyLock.new(action: :update, subject: MySubject.new) }
+      let(:owner) { MyOwner.new(my_locks: [subject_type_lock, subject_lock]) }
+
+      it 'returns true when lock for same action & subject_type' do
+        owner.has_lock?(subject_type_lock).must_equal true
+      end
+
+      it 'returns true when lock for same action & subject' do
+        owner.has_lock?(subject_lock).must_equal true
+      end
+
+      it 'returns false for non existing lock' do
+        owner.has_lock?(other_lock).must_equal false
+      end
+    end
+
   end
 end

data/test/mongoid_ability/subject_test.rb

@@ -2,41 +2,66 @@ require 'test_helper'
 
 module MongoidAbility
   describe Subject do
-    describe '.default_locks' do
 
+    describe '.default_lock' do
       before do
         MySubject.default_locks = []
         MySubject1.default_locks = []
+        MySubject2.default_locks = []
 
         MySubject.default_lock MyLock, :read, true
+        MySubject.default_lock MyLock, :update, true
         MySubject1.default_lock MyLock1, :update, false
       end
 
       it 'stores them' do
-        MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read)
+        MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read update)
         MySubject1.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(update)
       end
+    end
+
+    describe 'when lock not defined on superclass' do
+      before do
+        MySubject.default_locks = []
+        MySubject1.default_locks = []
+      end
+
+      it 'must raise error' do
+        -> { MySubject1.default_lock MyLock, :test, true }.must_raise StandardError
+      end
+    end
 
-      describe 'prevents conflicts' do
-        before do
-          # FIXME: this permanently adjusts the default test locks – ideally do this other way, stubs etc.
-          MySubject.default_lock MyLock, :read, false
-          MySubject.default_lock MyLock1, :read, false
-        end
+    describe 'prevents conflicts' do
+      before do
+        MySubject.default_locks = []
+        MySubject.default_lock MyLock, :read, false
+        MySubject.default_lock MyLock1, :read, false
+      end
 
-        it 'does not allow multiple locks for same action' do
-          MySubject.default_locks.select{ |l| l.action == :read }.count.must_equal 1
-        end
+      it 'does not allow multiple locks for same action' do
+        MySubject.default_locks.select{ |l| l.action == :read }.count.must_equal 1
+      end
 
-        it 'replace existing locks with new attributes' do
-          MySubject.default_locks.detect{ |l| l.action == :read }.outcome.must_equal false
-        end
+      it 'replace existing locks with new attributes' do
+        MySubject.default_locks.detect{ |l| l.action == :read }.outcome.must_equal false
+      end
 
-        it 'replaces existing locks with new one' do
-          MySubject.default_locks.detect{ |l| l.action == :read }.class.must_equal MyLock1
-        end
+      it 'replaces existing locks with new one' do
+        MySubject.default_locks.detect{ |l| l.action == :read }.class.must_equal MyLock1
       end
+    end
+
+    describe '.is_root_class?' do
+      it { MySubject.is_root_class?.must_equal true }
+      it { MySubject1.is_root_class?.must_equal false }
+      it { MySubject2.is_root_class?.must_equal false }
+    end
 
+    describe ".root_class" do
+      it { MySubject.root_class.must_equal MySubject }
+      it { MySubject1.root_class.must_equal MySubject }
+      it { MySubject2.root_class.must_equal MySubject }
     end
+
   end
 end

metadata

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