mongoid_ability 0.3.12 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43d40158fbfa09bdf0f359c67b2479fb2854018e
-  data.tar.gz: 5991679a87775917e3f9823048a4b6c56f13fc1c
+  metadata.gz: 7fc3874b06359df0fba37050d4d67178930055ff
+  data.tar.gz: d6b58a71fc1cea44d3777e8199f7a9c7d6c20cf4
 SHA512:
-  metadata.gz: c991cc35b5c519d08cfc1bb49b8df8d41648a55d3cbb13f82dcea1691fcbc500218374cc6d78609d07c69578cd4d1ba6d66fbbc4c16ed64b6eb59965b169424a
-  data.tar.gz: c983cf65e6e9d8e3276e6833173e866e857e1f7745426242d4285178118f6252cda3466ce6779540c91a65787eb04999f5bedb0a389217ce6466d4aef9b9854d
+  metadata.gz: 2b5a18e5d2662ba5e5edfb7cac7e7a0295eb78ad35affa6b879e009985978454dff6c0e142feacf0e2bccdd85142f3714f177a9bb4dfdfaa15a7ba89eb6faf34
+  data.tar.gz: a465b49e5904ee8b06fbed035b6a95a439fbb9fc3e5c79f4769de2b59a05702c986e3e64d0a94c60de73aa1fd71e9659f88cf283f7e3aa3a016199f6a3618b7d

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# 0.4.3
+
+* stub `default_locks` in tests to avoid brittle tests
+* fix the ability syntactic sugar to support both proc & direct call
+
+# 0.4.2
+
+* **yanked**
+* improved clarity in class naming
+
+# 0.4.1
+
+* **yanked**
+* `Resolver` classes now accept `subject_id` (instead of `subject`) for greater flexibility
+
+# 0.4.0
+
+* **yanked**
+* the `Resolver` classes refactored to return locks (instead of just an outcome)

data/lib/mongoid_ability.rb

@@ -6,6 +6,7 @@ require "mongoid_ability/lock"
 require "mongoid_ability/owner"
 require "mongoid_ability/subject"
 
+require "mongoid_ability/resolver"
 require "mongoid_ability/resolve_locks"
 require "mongoid_ability/resolve_default_locks"
 require "mongoid_ability/resolve_inherited_locks"

data/lib/mongoid_ability/ability.rb

@@ -14,39 +14,37 @@ module MongoidAbility
       subject_classes.reject { |cls| cls.superclass.included_modules.include?(MongoidAbility::Subject) }
     end
 
-    # =====================================================================
-
     def initialize(owner)
       @owner = owner
 
-      can do |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 unless outcome.nil?
+      can do |action, subject_type, subject, options = {}|
+        subject_id = subject ? subject.id : nil
+        if lock = ResolveLocks.call(owner, action, subject_type, subject_id, options)
+          lock.calculated_outcome(options)
         end
-
-        outcome
       end
     end
 
-    # ---------------------------------------------------------------------
-
     # lambda for easy permission checking:
     # .select(&current_ability.can_read)
     # .select(&current_ability.can_update)
     # .select(&current_ability.can_destroy)
     # etc.
-    # 
-    # TODO: allow to pass options .select(&current_ability.can_read(my_option: false))
-    #
     def method_missing(name, *args)
       return super unless name.to_s =~ /\A(can|cannot)_/
-      return unless action = name.to_s.gsub(/\A(can|cannot)_/, '').to_sym
-      name =~ /can_/ ? ->(doc) { can? action, doc } : ->(doc) { cannot? action, doc }
+      return unless action = name.to_s.scan(/\A(can|cannot)_(\w+)/).flatten.last.to_sym
+
+      if args.empty? || args.first.is_a?(Hash)
+        case name
+        when /can_/ then -> (doc) { can?(action, doc, *args) }
+        else -> (doc) { cannot?(action, doc, *args) }
+        end
+      else
+        case name
+        when /can_/ then can?(action, *args)
+        else cannot?(action, *args)
+        end
+      end
     end
   end
 end

data/lib/mongoid_ability/lock.rb

@@ -15,16 +15,17 @@ module MongoidAbility
         validates :action, presence: true, uniqueness: { scope: [:subject_type, :subject_id, :outcome] }
         validates :outcome, presence: true
 
-        scope :for_action, -> (action) { where(action: action.to_sym) }
+        scope :for_action, ->(action) { where(action: action.to_sym) }
 
-        scope :for_subject_type, -> (subject_type) { where(subject_type: subject_type.to_s) }
+        scope :for_subject_type, ->(subject_type) { where(subject_type: subject_type.to_s) }
+        scope :for_subject_types, ->(subject_types) { criteria.in(subject_type: subject_types) }
 
-        scope :for_subject_id, -> (subject_id) {
+        scope :for_subject_id, ->(subject_id) {
           return where(subject_id: nil) unless subject_id.present?
           where(subject_id: BSON::ObjectId.from_string(subject_id))
         }
 
-        scope :for_subject, -> (subject) {
+        scope :for_subject, ->(subject) {
           return where(subject_id: nil) unless subject.present?
           where(subject_type: subject.class.model_name, subject_id: subject.id)
         }
@@ -34,8 +35,6 @@ module MongoidAbility
       end
     end
 
-    # =====================================================================
-
     concerning :LockType do
       def class_lock?
         !id_lock?

data/lib/mongoid_ability/owner.rb

@@ -1,6 +1,6 @@
 module MongoidAbility
   module Owner
-    def self.included base
+    def self.included(base)
       base.extend ClassMethods
       base.class_eval do
         delegate :can?, :cannot?, to: :ability
@@ -8,8 +8,6 @@ module MongoidAbility
       end
     end
 
-    # ---------------------------------------------------------------------
-
     module ClassMethods
       def locks_relation_name
         :locks
@@ -20,32 +18,28 @@ module MongoidAbility
       end
     end
 
-    # ---------------------------------------------------------------------
-
     def locks_relation
-      self.send(self.class.locks_relation_name)
+      send(self.class.locks_relation_name)
     end
 
-    def locks_relation= val
-      self.send "#{self.class.locks_relation_name}=", val
+    def locks_relation=(val)
+      send "#{self.class.locks_relation_name}=", val
     end
 
     def inherit_from_relation
-      self.send(self.class.inherit_from_relation_name)
+      send(self.class.inherit_from_relation_name)
     end
 
     def ability
       @ability ||= MongoidAbility::Ability.new(self)
     end
 
-    # ---------------------------------------------------------------------
-
     def has_lock?(lock)
       @has_lock ||= {}
       @has_lock[lock] ||= locks_relation.where(action: lock.action, subject_type: lock.subject_type, subject_id: lock.subject_id.presence).cache.exists?
     end
 
-    private # =============================================================
+    private
 
     def cleanup_locks
       locks_relation.select(&:open?).each do |lock|

data/lib/mongoid_ability/resolve_default_locks.rb

@@ -1,11 +1,14 @@
 module MongoidAbility
-  class ResolveDefaultLocks < ResolveLocks
+  class ResolveDefaultLocks < Resolver
     def call
-      return false if default_locks.any? { |l| l.closed?(options) }
-      return true if default_locks.any? { |l| l.open?(options) }
+      closed_lock = default_locks.detect { |l| l.closed?(options) }
+      return closed_lock if closed_lock
+
+      open_lock = default_locks.detect { |l| l.open?(options) }
+      return open_lock if open_lock
     end
 
-    private # =============================================================
+    private
 
     def default_locks
       subject_class.default_locks.select { |l| l.action.to_s == action.to_s }

data/lib/mongoid_ability/resolve_inherited_locks.rb

@@ -1,30 +1,35 @@
 module MongoidAbility
-  class ResolveInheritedLocks < ResolveLocks
+  class ResolveInheritedLocks < Resolver
     def call
-      uo = user_outcome
-      return uo unless uo.nil?
+      owner_lock = resolved_owner_lock
+      return owner_lock if owner_lock
 
       if owner.respond_to?(owner.class.inherit_from_relation_name) && !owner.inherit_from_relation.nil?
-        io = owner.inherit_from_relation.collect { |inherited_owner| inherited_owner_outcome(inherited_owner) }.compact
-        return io.any? { |o| o == true } unless io.empty?
+        resolved_inherited_owner_locks = owner.inherit_from_relation.map { |inherited_owner| resolved_inherited_owner_lock(inherited_owner) }.compact
+
+        open_lock = resolved_inherited_owner_locks.detect { |l| l.open?(options) }
+        return open_lock if open_lock
+
+        closed_lock = resolved_inherited_owner_locks.detect { |l| l.closed?(options) }
+        return closed_lock if closed_lock
       end
 
-      default_outcome
+      resolved_default_lock
     end
 
-    private # =============================================================
+    private
 
-    def user_outcome
-      @user_outcome ||= ResolveOwnerLocks.call(owner, action, subject_class, subject, options)
+    def resolved_owner_lock
+      @resolved_owner_lock ||= ResolveOwnerLocks.call(owner, action, subject_class, subject_id, options)
     end
 
-    def inherited_owner_outcome(inherited_owner)
-      @inherited_owner_outcome ||= {}
-      @inherited_owner_outcome[inherited_owner] ||= ResolveOwnerLocks.call(inherited_owner, action, subject_class, subject, options)
+    def resolved_inherited_owner_lock(inherited_owner)
+      @resolved_inherited_owner_lock ||= {}
+      @resolved_inherited_owner_lock[inherited_owner] ||= ResolveOwnerLocks.call(inherited_owner, action, subject_class, subject_id, options)
     end
 
-    def default_outcome
-      @default_outcome ||= ResolveDefaultLocks.call(nil, action, subject_class, nil, options)
+    def resolved_default_lock
+      @resolved_default_lock ||= ResolveDefaultLocks.call(nil, action, subject_class, nil, options)
     end
   end
 end

data/lib/mongoid_ability/resolve_locks.rb

@@ -1,32 +1,12 @@
 module MongoidAbility
-  class ResolveLocks < Struct.new(:owner, :action, :subject_type, :subject, :options)
-    attr_reader(
-      :subject_class,
-      :subject_id
-    )
-
-    def self.call(*args)
-      new(*args).call
-    end
-
-    # =====================================================================
-
-    def initialize(*args)
-      super(*args)
-
-      @subject_class = subject_type.to_s.constantize
-      @subject_id = subject.id if subject.present?
-
-      fail StandardError, "#{subject_type} class does not have default locks" unless @subject_class.respond_to?(:default_locks)
-      fail StandardError, "#{subject_type} class does not have default lock for :#{action} action" unless @subject_class.self_and_ancestors_with_default_locks.any? do |cls|
-        cls.default_locks.any? { |l| l.action == action }
-      end
-    end
-
-    # =====================================================================
-
+  class ResolveLocks < Resolver
     def call
-      fail NotImplementedError
+      lock = nil
+      subject_class.self_and_ancestors_with_default_locks.each do |cls|
+        lock = ResolveInheritedLocks.call(owner, action, cls.to_s, subject_id, options)
+        break unless lock.nil?
+      end
+      lock
     end
   end
 end

data/lib/mongoid_ability/resolve_owner_locks.rb

@@ -1,7 +1,7 @@
 # OPTIMIZE: this seems quite expensive
 
 module MongoidAbility
-  class ResolveOwnerLocks < ResolveLocks
+  class ResolveOwnerLocks < Resolver
     def call
       return unless owner.respond_to?(:locks_relation)
 
@@ -9,17 +9,25 @@ module MongoidAbility
 
       return unless locks_for_subject_type.exists?
 
-      # return outcome if owner defines lock for id
+      # return lock if owner defines lock for id
       if subject_id.present?
         id_locks = locks_for_subject_type.id_locks.for_subject_id(subject_id).cache
-        return false if id_locks.any? { |l| l.closed?(options) }
-        return true if id_locks.any? { |l| l.open?(options) }
+
+        closed_lock = id_locks.detect { |l| l.closed?(options) }
+        return closed_lock if closed_lock
+
+        open_lock = id_locks.detect { |l| l.open?(options) }
+        return open_lock if open_lock
       end
 
-      # return outcome if owner defines lock for subject_type
+      # return lock if owner defines lock for subject_type
       class_locks = locks_for_subject_type.class_locks.cache
-      return false if class_locks.class_locks.any? { |l| l.closed?(options) }
-      return true if class_locks.class_locks.any? { |l| l.open?(options) }
+
+      closed_lock = class_locks.class_locks.detect { |l| l.closed?(options) }
+      return closed_lock if closed_lock
+
+      open_lock = class_locks.class_locks.detect { |l| l.open?(options) }
+      return open_lock if open_lock
 
       nil
     end

data/lib/mongoid_ability/resolver.rb

@@ -0,0 +1,24 @@
+module MongoidAbility
+  class Resolver < Struct.new(:owner, :action, :subject_type, :subject_id, :options)
+    attr_reader :subject_class
+
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(owner, action, subject_type, subject_id = nil, options = {})
+      super(owner, action, subject_type, subject_id, options)
+
+      @subject_class = subject_type.to_s.constantize
+
+      raise StandardError, "#{subject_type} class does not have default locks" unless @subject_class.respond_to?(:default_locks)
+      raise StandardError, "#{subject_type} class does not have default lock for :#{action} action" unless @subject_class.self_and_ancestors_with_default_locks.any? do |cls|
+        cls.default_locks.any? { |l| l.action == action }
+      end
+    end
+
+    def call
+      raise NotImplementedError
+    end
+  end
+end

data/lib/mongoid_ability/values_for_accessible_query.rb

@@ -4,6 +4,10 @@ module MongoidAbility
       new(*args).call
     end
 
+    def initialize(base_class, ability, action, options = {})
+      super(base_class, ability, action, options)
+    end
+
     # =====================================================================
 
     def call

data/lib/mongoid_ability/version.rb

@@ -1,3 +1,3 @@
 module MongoidAbility
-  VERSION = '0.3.12'.freeze
+  VERSION = '0.4.3'.freeze
 end

data/test/mongoid_ability/ability_basic_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe 'basic ability test' do
+    let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+    let(:owner) { MyRole.new(my_locks: [read_lock]) }
+    let(:ability) { Ability.new(owner) }
+
+    let(:default_locks) { [MyLock.new(action: :read, outcome: true)] }
+
+    it 'owner can?' do
+      MySubject.stub :default_locks, default_locks do
+        ability.can?(:read, MySubject).must_equal false
+      end
+    end
+
+    it 'owner cannot?' do
+      MySubject.stub :default_locks, default_locks do
+        ability.cannot?(:read, MySubject).must_equal true
+      end
+    end
+
+    it 'is accessible by' do
+      MySubject.stub :default_locks, default_locks do
+        MySubject.accessible_by(ability, :read).must_be_kind_of Mongoid::Criteria
+      end
+    end
+  end
+end

data/test/mongoid_ability/ability_syntactic_sugar_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module MongoidAbility
+  describe 'syntactic sugar' do
+    let(:read_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
+    let(:owner) { MyRole.new(my_locks: [read_lock]) }
+    let(:ability) { Ability.new(owner) }
+    let(:options) { { x: 1 } }
+
+    let(:default_locks) { [MyLock.new(action: :read, outcome: true)] }
+
+    it 'owner can?' do
+      MySubject.stub :default_locks, default_locks do
+        [MySubject].select(&ability.can_read(options)).must_equal []
+        [MySubject].select(&ability.can_read?(options)).must_equal []
+
+        ability.can_read(MySubject, options).must_equal false
+        ability.can_read?(MySubject, options).must_equal false
+      end
+    end
+
+    it 'owner cannot?' do
+      MySubject.stub :default_locks, default_locks do
+        [MySubject].select(&ability.cannot_read(options)).must_equal [MySubject]
+        [MySubject].select(&ability.cannot_read?(options)).must_equal [MySubject]
+
+        ability.cannot_read(MySubject, options).must_equal true
+        ability.cannot_read?(MySubject, options).must_equal true
+      end
+    end
+  end
+end