mongoid_ability 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 113e01e0daf944524f10664bf402096ad916a57e
-  data.tar.gz: 3c23744ac2b168352c8ba13739d762511f1a4d37
+  metadata.gz: 4380837ac3e83d99bb741c4f5fa31f70598500bf
+  data.tar.gz: 9537c54dfcb14ee4a9d0affd7fb9291c5ecc7e55
 SHA512:
-  metadata.gz: 1bc440f3326d1b305ff277b0c3a7b5dd577ad79c1808dc3c80d23917a534b645249f7e373f0d4a1d56da810300379d6d9d1754d3157a25b8df452fa05cfd740b
-  data.tar.gz: 62a122fad732b65ece84495df5ec7240d6c54912a363ef3d76f4bea1188490e4e8da53eadf4b25a5aab999b2e3472e2ce32e4ec2ffc1a6b20643bc99db07a0b9
+  metadata.gz: 37dbd56daf307a7af85f54a254dde5a9546059fea164540dd2c3512b8543587c8f42278c49169134e2acc66d3194457117c10ae1201712baba685bbccb0b5a42
+  data.tar.gz: 25cd98e83f5145b3b694a6e689ae9d533558752b3f4f17561b2420c85fde2be068b5250d0099d33c2cc394012359722aa5175629c86df392dc493133dec8978e

data/lib/mongoid_ability/ability.rb

@@ -20,55 +20,17 @@ module MongoidAbility
       @owner = owner
 
       can do |action, subject_type, subject, options|
-        _can(action, subject_type, subject, options)
+        subject_class = subject_type.to_s.constantize
+        outcome = nil
+        options ||= {}
 
-        # if defined? Rails
-        #   ::Rails.cache.fetch( [ cache_key ] + cache_keys(action, subject_type, subject, options) ) do
-        #     _can(action, subject_type, subject, options)
-        #   end
-        # else
-        #   _can(action, subject_type, subject, options)
-        # end
-      end
-    end
-
-    # ---------------------------------------------------------------------
+        subject_class.self_and_ancestors_with_default_locks.each do |cls|
+          outcome = ResolveInheritedLocks.call(owner, action, cls, subject, options)
+          break if outcome != nil
+        end
 
-    def _can action, subject_type, subject, options
-      subject_class = subject_type.to_s.constantize
-      outcome = nil
-      options ||= {}
-
-      subject_class.self_and_ancestors_with_default_locks.each do |cls|
-        outcome = ResolveInheritedLocks.call(owner, action, cls, subject, options)
-        break if outcome != nil
+        outcome
       end
-
-      outcome
-    end
-
-    # ---------------------------------------------------------------------
-
-    def cache_key
-      ["ability", owner.cache_key, inherit_from_relation_cache_keys].compact.join('/')
-    end
-
-    def cache_keys action, subject_type, subject, options
-      res = []
-      res << action
-      res << subject_type
-      res << subject.cache_key unless subject.nil?
-      res << options_cache_key(options)
-      res.compact
-    end
-
-    def options_cache_key options={}
-      Digest::SHA1.hexdigest( options.to_a.sort_by { |k,v| k.to_s }.to_s )
-    end
-
-    def inherit_from_relation_cache_keys
-      return unless owner.respond_to?(owner.class.inherit_from_relation_name) && owner.inherit_from_relation != nil
-      owner.inherit_from_relation.map(&:cache_key)
     end
 
     # ---------------------------------------------------------------------

data/lib/mongoid_ability/accessible_query_builder.rb

@@ -1,3 +1,5 @@
+# FIXME: this is extremely slow and not suitable for use, yet
+
 module MongoidAbility
   class AccessibleQueryBuilder < Struct.new(:base_class, :ability, :action, :options)
 
@@ -8,24 +10,11 @@ module MongoidAbility
     # =====================================================================
 
     def call
-      _call
-
-      # if defined? Rails
-      #   # FIXME: this is a bit of a dirty hack, since the marshalling of criteria does not preserve the embedded attributes
-      #   Rails.cache.fetch( [ 'ability-query', base_class, ability.cache_key, action, ability.options_cache_key(options) ] ) do
-      #     _call
-      #   end.tap { |c| c.embedded = base_criteria.embedded }
-      # else
-      #   _call
-      # end
+      base_class_and_descendants.inject(base_criteria) { |criteria, cls| criteria.merge!(criteria_for_class(cls)) }
     end
 
     private # =============================================================
 
-    def _call
-      base_class_and_descendants.inject(base_criteria) { |criteria, cls| criteria.merge!(criteria_for_class(cls)) }
-    end
-
     def base_criteria
       @base_criteria ||= base_class.criteria
     end

data/lib/mongoid_ability/lock.rb

@@ -40,8 +40,20 @@ module MongoidAbility
       res
     end
 
+    # calculates outcome as if this lock is not present
+    def inherited_outcome
+      return 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)
+    end
+
     # ---------------------------------------------------------------------
 
+    def subject_class
+      subject_type.constantize
+    end
+
     def open? options={}
       calculated_outcome(options) == true
     end

data/lib/mongoid_ability/owner.rb

@@ -26,6 +26,10 @@ module MongoidAbility
       self.send(self.class.locks_relation_name)
     end
 
+    def locks_relation= val
+      self.send "#{self.class.locks_relation_name}=", val
+    end
+
     def inherit_from_relation
       self.send(self.class.inherit_from_relation_name)
     end

data/lib/mongoid_ability/version.rb

@@ -1,3 +1,3 @@
 module MongoidAbility
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/test/mongoid_ability/lock_test.rb

@@ -49,6 +49,27 @@ module MongoidAbility
 
     # ---------------------------------------------------------------------
 
+    describe '#inherited_outcome' do
+      let(:my_subject) { MySubject.new }
+      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
+
+      it 'does not affect calculated_outcome' do
+        ability.can?(:read, my_subject).must_equal true
+      end
+
+      it 'returns calculated_outcome without this lock' do
+        subject_lock.inherited_outcome.must_equal false
+        subject_type_lock.inherited_outcome.must_equal true
+      end
+    end
+
+    # ---------------------------------------------------------------------
+
     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) }

metadata

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