mongoid_ability 1.0.0 → 2.0.0

data/test/test_helper.rb

@@ -25,8 +25,18 @@ DatabaseCleaner.orm = :mongoid
 DatabaseCleaner.strategy = :truncation
 
 class MiniTest::Spec
-  before(:each) { DatabaseCleaner.start }
-  after(:each) { DatabaseCleaner.clean }
+  before(:each) do
+    DatabaseCleaner.start
+  end
+
+  after(:each) do
+    [ MySubject, 
+      MySubject1, MySubject2,
+      MySubject11, MySubject21
+    ].each(&:reset_default_locks!)
+
+    DatabaseCleaner.clean
+  end
 end
 
 class Object

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_ability
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Tomas Celizna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-08 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancancan
@@ -153,33 +153,28 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/cancancan/model_adapters/mongoid_adapter.rb
+- lib/cancancan/model_additions.rb
 - lib/mongoid_ability.rb
 - lib/mongoid_ability/ability.rb
-- lib/mongoid_ability/accessible_query_builder.rb
+- lib/mongoid_ability/find_lock.rb
 - lib/mongoid_ability/lock.rb
+- lib/mongoid_ability/locks_decorator.rb
 - lib/mongoid_ability/owner.rb
-- lib/mongoid_ability/resolve_default_locks.rb
-- lib/mongoid_ability/resolve_inherited_locks.rb
-- lib/mongoid_ability/resolve_locks.rb
-- lib/mongoid_ability/resolve_owner_locks.rb
-- lib/mongoid_ability/resolver.rb
 - lib/mongoid_ability/subject.rb
-- lib/mongoid_ability/values_for_accessible_query.rb
 - lib/mongoid_ability/version.rb
 - mongoid_ability.gemspec
+- test/cancancan/model_adapters/mongoid_adapter_options_test.rb
+- test/cancancan/model_adapters/mongoid_adapter_test.rb
+- test/mongoid_ability/ability_basic_benchmark.rb
 - test/mongoid_ability/ability_basic_test.rb
-- test/mongoid_ability/ability_syntactic_sugar_test.rb
+- test/mongoid_ability/ability_marshal_test.rb
+- test/mongoid_ability/ability_options_test.rb
 - test/mongoid_ability/ability_test.rb
-- test/mongoid_ability/accessible_query_builder_test.rb
-- test/mongoid_ability/can_options_test.rb
+- test/mongoid_ability/find_lock_test.rb
 - test/mongoid_ability/lock_test.rb
 - test/mongoid_ability/owner_locks_test.rb
 - test/mongoid_ability/owner_test.rb
-- test/mongoid_ability/resolve_default_locks_test.rb
-- test/mongoid_ability/resolve_inherited_locks_test.rb
-- test/mongoid_ability/resolve_owner_locks_test.rb
-- test/mongoid_ability/resolver_test.rb
-- test/mongoid_ability/subject_accessible_by_test.rb
 - test/mongoid_ability/subject_test.rb
 - test/support/expectations.rb
 - test/support/test_classes/my_lock.rb
@@ -213,19 +208,17 @@ specification_version: 4
 summary: Custom Ability class that allows CanCanCan authorization library store permissions
   in MongoDB via the Mongoid gem.
 test_files:
+- test/cancancan/model_adapters/mongoid_adapter_options_test.rb
+- test/cancancan/model_adapters/mongoid_adapter_test.rb
+- test/mongoid_ability/ability_basic_benchmark.rb
 - test/mongoid_ability/ability_basic_test.rb
-- test/mongoid_ability/ability_syntactic_sugar_test.rb
+- test/mongoid_ability/ability_marshal_test.rb
+- test/mongoid_ability/ability_options_test.rb
 - test/mongoid_ability/ability_test.rb
-- test/mongoid_ability/accessible_query_builder_test.rb
-- test/mongoid_ability/can_options_test.rb
+- test/mongoid_ability/find_lock_test.rb
 - test/mongoid_ability/lock_test.rb
 - test/mongoid_ability/owner_locks_test.rb
 - test/mongoid_ability/owner_test.rb
-- test/mongoid_ability/resolve_default_locks_test.rb
-- test/mongoid_ability/resolve_inherited_locks_test.rb
-- test/mongoid_ability/resolve_owner_locks_test.rb
-- test/mongoid_ability/resolver_test.rb
-- test/mongoid_ability/subject_accessible_by_test.rb
 - test/mongoid_ability/subject_test.rb
 - test/support/expectations.rb
 - test/support/test_classes/my_lock.rb

data/lib/mongoid_ability/accessible_query_builder.rb

@@ -1,64 +0,0 @@
-module MongoidAbility
-  class AccessibleQueryBuilder < Struct.new(:base_class, :ability, :action, :options)
-    def self.call(*args)
-      new(*args).call
-    end
-
-    def initialize(base_class, ability, action, options = {})
-      super(base_class, ability, action, options)
-    end
-
-    # =====================================================================
-
-    def call
-      base_class.criteria.where(conditions)
-    end
-
-    def conditions
-      { '$and' => [{ '$or' => [closed_types_condition, open_types_and_ids_condition] }, closed_ids_condition] }
-    end
-
-    private # =============================================================
-
-    def closed_types_condition
-      { type_key => { '$nin' => values.closed_types.uniq } }
-    end
-
-    def open_types_and_ids_condition
-      {
-        type_key => { '$in' => values.open_types_and_ids.map(&:type).uniq },
-        id_key => { '$in' => values.open_types_and_ids.map(&:id).uniq }
-      }
-    end
-
-    def closed_ids_condition
-      { id_key => { '$nin' => values.closed_ids.uniq } }
-    end
-
-    # ---------------------------------------------------------------------
-
-    def values
-      @values ||= base_class.values_for_accessible_query(ability, action, options)
-    end
-
-    # ---------------------------------------------------------------------
-
-    def base_class_superclass
-      @base_class_superclass ||= (base_class.ancestors_with_default_locks.last || base_class)
-    end
-
-    # ---------------------------------------------------------------------
-
-    def prefix
-      options.fetch(:prefix, nil)
-    end
-
-    def id_key
-      [prefix, '_id'].reject(&:blank?).join.to_sym
-    end
-
-    def type_key
-      [prefix, '_type'].reject(&:blank?).join.to_sym
-    end
-  end
-end

data/lib/mongoid_ability/resolve_default_locks.rb

@@ -1,17 +0,0 @@
-module MongoidAbility
-  class ResolveDefaultLocks < Resolver
-    def call
-      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
-
-    def default_locks
-      subject_class.default_locks.select { |l| l.action.to_s == action.to_s }
-    end
-  end
-end

data/lib/mongoid_ability/resolve_inherited_locks.rb

@@ -1,35 +0,0 @@
-module MongoidAbility
-  class ResolveInheritedLocks < Resolver
-    def call
-      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?
-        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
-
-      resolved_default_lock
-    end
-
-    private
-
-    def resolved_owner_lock
-      @resolved_owner_lock ||= ResolveOwnerLocks.call(owner, action, subject_class, subject_id, options)
-    end
-
-    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 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,12 +0,0 @@
-module MongoidAbility
-  class ResolveLocks < Resolver
-    def call
-      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,35 +0,0 @@
-# OPTIMIZE: this seems quite expensive
-
-module MongoidAbility
-  class ResolveOwnerLocks < Resolver
-    def call
-      return unless owner.respond_to?(:locks_relation)
-
-      locks_for_subject_type = owner.locks_relation.for_action(action).for_subject_type(subject_type).cache
-
-      return unless locks_for_subject_type.exists?
-
-      # 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
-
-        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 lock if owner defines lock for subject_type
-      class_locks = locks_for_subject_type.class_locks.cache
-
-      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
-  end
-end

data/lib/mongoid_ability/resolver.rb

@@ -1,24 +0,0 @@
-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

@@ -1,74 +0,0 @@
-module MongoidAbility
-  class ValuesForAccessibleQuery < Struct.new(:base_class, :ability, :action, :options)
-    def self.call(*args)
-      new(*args).call
-    end
-
-    def initialize(base_class, ability, action, options = {})
-      super(base_class, ability, action, options)
-    end
-
-    # =====================================================================
-
-    def call
-      closed_types = [] # [cls]
-      open_types_and_ids = [] # OpenStruct.new(type: …, id: …)
-      closed_ids = [] # [id]
-
-      base_class_and_descendants.each do |cls|
-        closed_types << cls.to_s if ability.cannot?(action, cls, options)
-        id_locks(cls).each do |lock|
-          if ability.can?(action, cls.new(_id: lock.subject_id), options)
-            open_types_and_ids << OpenStruct.new(type: cls.to_s, id: lock.subject_id)
-          else
-            closed_ids << lock.subject_id
-          end
-        end
-      end
-
-      OpenStruct.new(
-        closed_types: closed_types,
-        open_types_and_ids: open_types_and_ids,
-        closed_ids: closed_ids
-      )
-    end
-
-    private # =============================================================
-
-    def base_class_and_descendants
-      @base_class_and_descendants ||= [base_class].concat(base_class.descendants)
-    end
-
-    # ---------------------------------------------------------------------
-
-    def id_locks(cls)
-      (Array(owner_id_locks_for_subject_type(cls)) + Array(inherited_from_relation_ids_locks_for_subject_type(cls))).flatten
-    end
-
-    def owner_id_locks_for_subject_type(cls)
-      @owner_id_locks_for_subject_type ||= {}
-      @owner_id_locks_for_subject_type[cls] ||= owner.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s).cache
-    end
-
-    def inherited_from_relation_ids_locks_for_subject_type(cls)
-      return [] unless inherited_from_relation
-      @inherited_from_relation_ids_locks_for_subject_type ||= {}
-      @inherited_from_relation_ids_locks_for_subject_type[cls] ||= inherited_from_relation.collect do |o|
-        o.locks_relation.id_locks.for_action(action).for_subject_type(cls.to_s).cache
-      end.flatten
-    end
-
-    # ---------------------------------------------------------------------
-
-    def owner
-      @owner ||= ability.owner
-    end
-
-    # ---------------------------------------------------------------------
-
-    def inherited_from_relation
-      return unless owner.respond_to?(owner.class.inherit_from_relation_name)
-      owner.inherit_from_relation
-    end
-  end
-end

data/test/mongoid_ability/ability_syntactic_sugar_test.rb

@@ -1,32 +0,0 @@
-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

data/test/mongoid_ability/accessible_query_builder_test.rb

@@ -1,119 +0,0 @@
-require 'test_helper'
-
-module MongoidAbility
-  describe AccessibleQueryBuilder do
-    let(:base_class) { MySubject }
-    let(:owner) { MyOwner.new }
-    let(:ability) { Ability.new(owner) }
-    let(:action) { :read }
-    let(:options) { Hash.new }
-
-    let(:my_subject_default_locks) { [MyLock.new(subject_type: MySubject, action: :read, outcome: true)] }
-    let(:my_subject_1_default_locks) { [MyLock.new(subject_type: MySubject1, action: :false, outcome: true)] }
-    let(:my_subject_2_default_locks) { [] }
-
-    subject { AccessibleQueryBuilder.call(base_class, ability, action, options) }
-
-    it 'returns Mongoid::Criteria' do
-      MySubject.stub :default_locks, my_subject_default_locks do
-        MySubject1.stub :default_locks, my_subject_1_default_locks do
-          MySubject2.stub :default_locks, my_subject_2_default_locks do
-            subject.must_be_kind_of Mongoid::Criteria
-          end
-        end
-      end
-    end
-
-    describe 'prefix' do
-      let(:my_subject) { MySubject.create! }
-      let(:my_subject_1) { MySubject1.create! }
-      let(:my_subject_2) { MySubject2.create! }
-      let(:prefix) { :foo }
-
-      before do
-        my_subject; my_subject_1
-        owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-      end
-
-      it 'allows to pass prefix' do
-        MySubject.stub :default_locks, my_subject_default_locks do
-          MySubject1.stub :default_locks, my_subject_1_default_locks do
-            MySubject2.stub :default_locks, my_subject_2_default_locks do
-              selector = AccessibleQueryBuilder.call(base_class, ability, action, prefix: prefix).selector
-              selector.must_equal('$and' => [{ '$or' => [{ "#{prefix}_type" => { '$nin' => ['MongoidAbility::MySubject', 'MongoidAbility::MySubject1', 'MongoidAbility::MySubject2'] } }, { "#{prefix}_type" => { '$in' => [] }, "#{prefix}_id" => { '$in' => [] } }] }, { "#{prefix}_id" => { '$nin' => [] } }])
-            end
-          end
-        end
-      end
-    end
-
-    # ---------------------------------------------------------------------
-
-    describe 'closed_types' do
-      let(:my_subject) { MySubject.create! }
-      let(:my_subject_1) { MySubject1.create! }
-
-      before do
-        my_subject; my_subject_1
-        owner.my_locks = [MyLock.new(subject_type: MySubject, action: :read, outcome: false)]
-      end
-
-      it 'does not return subject with that id' do
-        MySubject.stub :default_locks, my_subject_default_locks do
-          MySubject1.stub :default_locks, my_subject_1_default_locks do
-            MySubject2.stub :default_locks, my_subject_2_default_locks do
-              MySubject.accessible_by(ability, :read).wont_include my_subject
-              MySubject.accessible_by(ability, :read).wont_include my_subject_1
-              MySubject1.accessible_by(ability, :read).wont_include my_subject_1
-            end
-          end
-        end
-      end
-    end
-
-    describe 'closed_ids' do
-      let(:my_subject_a) { MySubject.create! }
-      let(:my_subject_b) { MySubject.create! }
-
-      before do
-        my_subject_a; my_subject_b
-        owner.my_locks = [MyLock.new(subject: my_subject_a, action: :read, outcome: false)]
-      end
-
-      it 'does not return subject with that id' do
-        MySubject.stub :default_locks, my_subject_default_locks do
-          MySubject1.stub :default_locks, my_subject_1_default_locks do
-            MySubject2.stub :default_locks, my_subject_2_default_locks do
-              MySubject.accessible_by(ability, :read).wont_include my_subject_a
-              MySubject.accessible_by(ability, :read).must_include my_subject_b
-            end
-          end
-        end
-      end
-    end
-
-    describe 'closed_types & open_ids' do
-      let(:my_subject) { MySubject.create! }
-      let(:my_subject_1) { MySubject1.create! }
-
-      before do
-        owner.my_locks = [
-          MyLock.new(subject_type: MySubject, action: :read, outcome: false),
-          MyLock.new(subject: my_subject, action: :read, outcome: true),
-          MyLock.new(subject: my_subject_1, action: :read, outcome: true)
-        ]
-      end
-
-      it 'does not return subject with that id' do
-        MySubject.stub :default_locks, my_subject_default_locks do
-          MySubject1.stub :default_locks, my_subject_1_default_locks do
-            MySubject2.stub :default_locks, my_subject_2_default_locks do
-              MySubject.accessible_by(ability, :read).must_include my_subject
-              MySubject.accessible_by(ability, :read).must_include my_subject_1
-            end
-          end
-        end
-      end
-    end
-  end
-end