mongoid_ability 3.0.0 → 3.0.2

data/test/mongoid_ability/ability_test.rb

@@ -6,30 +6,32 @@ module MongoidAbility
     let(:ability) { Ability.new(owner) }
 
     it 'exposes owner' do
-      ability.owner.must_equal owner
+      _(ability.owner).must_equal owner
     end
 
     describe 'default locks' do
-      before(:all) { MySubject.default_lock MyLock, :update, true }
-      after(:all) { [MySubject, MySubject1, MySubject2, MySubject11, MySubject21].each(&:reset_default_locks!) }
+      after(:all) do
+        [MySubject, MySubject1, MySubject2, MySubject11, MySubject21]
+          .each(&:reset_default_locks!)
+      end
+
+      it 'propagates from superclass to subclasses' do
+        MySubject.default_lock MyLock, :update, true
 
-      it 'propagates from superclass to all subclasses' do
-        ability.can?(:update, MySubject).must_equal true
-        ability.can?(:update, MySubject1).must_equal true
-        ability.can?(:update, MySubject2).must_equal true
+        _(ability.can?(:update, MySubject)).must_equal true
+        _(ability.can?(:update, MySubject1)).must_equal true
+        _(ability.can?(:update, MySubject2)).must_equal true
       end
-    end
 
-    describe 'when defined for all superclasses' do
-      before(:all) do
+      it 'supersedes superclass locks' do
         MySubject.default_lock MyLock, :read, false
         MySubject1.default_lock MyLock, :read, true
         MySubject2.default_lock MyLock, :read, false
-      end
 
-      it { ability.can?(:read, MySubject).must_equal false }
-      it { ability.can?(:read, MySubject1).must_equal true }
-      it { ability.can?(:read, MySubject2).must_equal false }
+        _(ability.can?(:read, MySubject)).must_equal false
+        _(ability.can?(:read, MySubject1)).must_equal true
+        _(ability.can?(:read, MySubject2)).must_equal false
+      end
     end
 
     describe 'when defined for some superclasses' do
@@ -40,25 +42,21 @@ module MongoidAbility
       end
 
       it 'propagates default locks to subclasses' do
-        ability.can?(:read, MySubject).must_equal false
-        ability.can?(:read, MySubject1).must_equal false
-        ability.can?(:read, MySubject2).must_equal true
+        _(ability.can?(:read, MySubject)).must_equal false
+        _(ability.can?(:read, MySubject1)).must_equal false
+        _(ability.can?(:read, MySubject2)).must_equal true
       end
     end
 
-    # ---------------------------------------------------------------------
-
     describe 'user locks' do
       describe 'when defined for superclass' do
         let(:owner) { MyOwner.new(my_locks: [MyLock.new(subject_type: MySubject, action: :read, outcome: true)]) }
         before(:all) { MySubject.default_lock MyLock, :read, false }
 
-        it { ability.can?(:read, MySubject2).must_equal true }
+        it { _(ability.can?(:read, MySubject2)).must_equal true }
       end
     end
 
-    # ---------------------------------------------------------------------
-
     describe 'inherited owner locks' do
       describe 'when multiple inherited owners' do
         let(:owner) do
@@ -70,7 +68,7 @@ module MongoidAbility
 
         before(:all) { MySubject.default_lock MyLock, :read, false }
 
-        it { ability.can?(:read, MySubject).must_equal true }
+        it { _(ability.can?(:read, MySubject)).must_equal true }
       end
 
       describe 'when defined for superclass' do
@@ -82,12 +80,10 @@ module MongoidAbility
 
         before(:all) { MySubject.default_lock MyLock, :read, false }
 
-        it { ability.can?(:read, MySubject2).must_equal true }
+        it { _(ability.can?(:read, MySubject2)).must_equal true }
       end
     end
 
-    # ---------------------------------------------------------------------
-
     describe 'combined locks' do
       describe 'user and role locks' do
         let(:role_lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
@@ -98,7 +94,7 @@ module MongoidAbility
 
         before(:all) { MySubject.default_lock MyLock, :read, false }
 
-        it { ability.can?(:read, MySubject).must_equal false }
+        it { _(ability.can?(:read, MySubject)).must_equal false }
       end
 
       describe 'roles and default locks' do
@@ -109,13 +105,13 @@ module MongoidAbility
           let(:role) { MyRole.new(my_locks: [lock]) }
           let(:owner) { MyOwner.new(my_roles: [role]) }
 
-          it { ability.can?(:read, MySubject).must_equal true }
+          it { _(ability.can?(:read, MySubject)).must_equal true }
 
           describe 'subclass' do
             let(:lock) { MyLock.new(subject_type: MySubject1, action: :read, outcome: true) }
 
-            it { ability.can?(:read, MySubject).must_equal false }
-            it { ability.can?(:read, MySubject1).must_equal true }
+            it { _(ability.can?(:read, MySubject)).must_equal false }
+            it { _(ability.can?(:read, MySubject1)).must_equal true }
           end
         end
 
@@ -126,13 +122,13 @@ module MongoidAbility
           let(:role) { MyRole.new(my_locks: [lock]) }
           let(:owner) { MyOwner.new(my_roles: [role]) }
 
-          it { ability.can?(:read, MySubject).must_equal false }
+          it { _(ability.can?(:read, MySubject)).must_equal false }
 
           describe 'subclass' do
             let(:lock) { MyLock.new(subject_type: MySubject1, action: :read, outcome: false) }
 
-            it { ability.can?(:read, MySubject).must_equal true }
-            it { ability.can?(:read, MySubject1).must_equal false }
+            it { _(ability.can?(:read, MySubject)).must_equal true }
+            it { _(ability.can?(:read, MySubject1)).must_equal false }
           end
         end
 
@@ -146,8 +142,8 @@ module MongoidAbility
           let(:role) { MyRole.new(my_locks: [lock]) }
           let(:owner) { MyOwner.new(my_roles: [role]) }
 
-          it { ability.can?(:read, MySubject).must_equal true }
-          it { ability.can?(:read, MySubject1).must_equal false }
+          it { _(ability.can?(:read, MySubject)).must_equal true }
+          it { _(ability.can?(:read, MySubject1)).must_equal false }
         end
       end
     end

data/test/mongoid_ability/find_lock_test.rb

@@ -7,8 +7,8 @@ module MongoidAbility
     describe 'default lock' do
       before { MySubject.default_lock MyLock, :read, true }
 
-      it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
-      it { FindLock.call(owner, :read, MySubject1).must_equal MySubject.default_locks.for_action(:read).first }
+      it { _(FindLock.call(owner, :read, MySubject)).must_equal MySubject.default_locks.for_action(:read).first }
+      it { _(FindLock.call(owner, :read, MySubject1)).must_equal MySubject.default_locks.for_action(:read).first }
     end
 
     describe 'inherited lock' do
@@ -18,7 +18,7 @@ module MongoidAbility
       let(:role) { MyRole.new(my_locks: [lock]) }
       let(:owner) { MyOwner.new(my_roles: [role]) }
 
-      it { FindLock.call(owner, :read, MySubject).must_equal lock }
+      it { _(FindLock.call(owner, :read, MySubject)).must_equal lock }
 
       describe 'conflicting locks' do
         let(:lock_1) { MyLock.new(subject_type: MySubject, action: :read, outcome: true) }
@@ -28,7 +28,7 @@ module MongoidAbility
         let(:role_2) { MyRole.new(my_locks: [lock_2]) }
         let(:owner) { MyOwner.new(my_roles: [role_1, role_2]) }
 
-        it { FindLock.call(owner, :read, MySubject).must_equal lock_1 }
+        it { _(FindLock.call(owner, :read, MySubject)).must_equal lock_1 }
       end
 
       describe 'id lock' do
@@ -39,8 +39,8 @@ module MongoidAbility
         let(:role) { MyRole.new(my_locks: [lock_1, lock_2]) }
         let(:owner) { MyOwner.new(my_roles: [role]) }
 
-        it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
-        it { FindLock.call(owner, :read, my_subject.class, my_subject.id).must_equal lock_1 }
+        it { _(FindLock.call(owner, :read, MySubject)).must_equal MySubject.default_locks.for_action(:read).first }
+        it { _(FindLock.call(owner, :read, my_subject.class, my_subject.id)).must_equal lock_1 }
       end
     end
 
@@ -50,7 +50,7 @@ module MongoidAbility
       let(:lock) { MyLock.new(subject_type: MySubject, action: :read, outcome: false) }
       let(:owner) { MyOwner.new(my_locks: [lock]) }
 
-      it { FindLock.call(owner, :read, MySubject).must_equal lock }
+      it { _(FindLock.call(owner, :read, MySubject)).must_equal lock }
 
       describe 'id lock' do
         let(:my_subject) { MySubject.new }
@@ -59,8 +59,8 @@ module MongoidAbility
         let(:lock_2) { MyLock.new(subject_type: other_subject.model_name, subject_id: other_subject.id, action: :read, outcome: false) }
         let(:owner) { MyOwner.new(my_locks: [lock_1, lock_2]) }
 
-        it { FindLock.call(owner, :read, MySubject).must_equal MySubject.default_locks.for_action(:read).first }
-        it { FindLock.call(owner, :read, my_subject.class, my_subject.id).must_equal lock_1 }
+        it { _(FindLock.call(owner, :read, MySubject)).must_equal MySubject.default_locks.for_action(:read).first }
+        it { _(FindLock.call(owner, :read, my_subject.class, my_subject.id)).must_equal lock_1 }
       end
     end
   end

data/test/mongoid_ability/lock_test.rb

@@ -7,51 +7,43 @@ module MongoidAbility
     let(:my_subject) { MySubject.new }
     let(:inherited_lock) { MyLock1.new }
 
-    # ---------------------------------------------------------------------
-
-    it { subject.must_respond_to :action }
-    it { subject.must_respond_to :outcome }
-    it { subject.must_respond_to :subject }
-    it { subject.must_respond_to :subject_id }
-    it { subject.must_respond_to :subject_type }
-    it { subject.must_respond_to :owner }
-
-    # ---------------------------------------------------------------------
+    it { _(subject).must_respond_to :action }
+    it { _(subject).must_respond_to :outcome }
+    it { _(subject).must_respond_to :subject }
+    it { _(subject).must_respond_to :subject_id }
+    it { _(subject).must_respond_to :subject_type }
+    it { _(subject).must_respond_to :owner }
 
     it '#open?' do
-      subject.must_respond_to :open?
-      subject.open?.must_equal false
+      _(subject).must_respond_to :open?
+      _(subject.open?).must_equal false
     end
 
     it '#closed?' do
-      subject.must_respond_to :closed?
-      subject.closed?.must_equal true
+      _(subject).must_respond_to :closed?
+      _(subject.closed?).must_equal true
     end
 
     it '#class_lock?' do
-      subject.must_respond_to :class_lock?
+      _(subject).must_respond_to :class_lock?
     end
 
     it '#id_lock?' do
-      subject.must_respond_to :id_lock?
+      _(subject).must_respond_to :id_lock?
     end
 
-    # ---------------------------------------------------------------------
-
     describe '.subject_id' do
       it 'converts legal id String to BSON' do
         id = BSON::ObjectId.new
-        MyLock.for_subject_id(id.to_s).selector['subject_id'].must_be_kind_of BSON::ObjectId
+        _(MyLock.for_subject_id(id.to_s).selector['subject_id']).must_be_kind_of BSON::ObjectId
       end
 
       it 'converts empty String to nil' do
         id = ''
-        MyLock.for_subject_id(id.to_s).selector['subject_id'].must_be_nil
+        _(MyLock.for_subject_id(id.to_s).selector['subject_id']).must_be_nil
       end
     end
 
-    # ---------------------------------------------------------------------
-
     describe 'sort' do
       let(:lock0) { MyLock.new(subject_type: MySubject, action: :update, outcome: false) }
       let(:lock1) { MyLock.new(subject_type: MySubject, action: :update, outcome: true) }
@@ -63,12 +55,10 @@ module MongoidAbility
 
       let(:sorted_locks) { owner.my_locks.sort(&Lock.sort) }
 
-      it { sorted_locks[0].must_equal lock4 }
-      it { sorted_locks[3].must_equal lock1 }
+      it { _(sorted_locks[0]).must_equal lock4 }
+      it { _(sorted_locks[3]).must_equal lock1 }
     end
 
-    # ---------------------------------------------------------------------
-
     describe '#inherited_outcome' do
       before(:all) { MySubject.default_lock MyLock, :read, true }
 
@@ -83,11 +73,11 @@ module MongoidAbility
       let(:subject_lock) { owner.my_locks.detect(&:id_lock?) }
       let(:default_lock) { MySubject.default_locks.detect { |l| l.action == :read } }
 
-      it { ability.can?(:read, my_subject).must_equal true }
+      it { _(ability.can?(:read, my_subject)).must_equal true }
 
-      it { subject_lock.inherited_outcome.must_equal false }
-      it { subject_type_lock.inherited_outcome.must_equal true }
-      it { default_lock.inherited_outcome.must_equal true }
+      it { _(subject_lock.inherited_outcome).must_equal false }
+      it { _(subject_type_lock.inherited_outcome).must_equal true }
+      it { _(default_lock.inherited_outcome).must_equal true }
     end
   end
 end

data/test/mongoid_ability/owner_locks_test.rb

@@ -13,8 +13,8 @@ module MongoidAbility
 
       before(:all) { MySubject.default_lock MyLock, :read, true }
 
-      it { ability.can?(:read, subject.class).must_equal true }
-      it { ability.can?(:read, subject).must_equal false }
+      it { _(ability.can?(:read, subject.class)).must_equal true }
+      it { _(ability.can?(:read, subject)).must_equal false }
     end
 
     describe 'when lock for subject type' do
@@ -23,8 +23,8 @@ module MongoidAbility
 
       before(:all) { MySubject.default_lock MyLock, :read, true }
 
-      it { ability.can?(:read, subject.class).must_equal false }
-      it { ability.can?(:read, subject).must_equal false }
+      it { _(ability.can?(:read, subject.class)).must_equal false }
+      it { _(ability.can?(:read, subject)).must_equal false }
     end
   end
 end

data/test/mongoid_ability/owner_test.rb

@@ -13,11 +13,11 @@ module MongoidAbility
         subject.run_callbacks(:save)
       end
 
-      it { subject.my_locks.sort(&Lock.sort).must_equal [closed_lock].sort(&Lock.sort) }
+      it { _(subject.my_locks.sort(&Lock.sort)).must_equal [closed_lock].sort(&Lock.sort) }
 
       describe 'locks relation' do
-        it { subject.class.locks_relation_name.must_equal :my_locks }
-        it { subject.reflect_on_association(:my_locks).name.must_equal :my_locks }
+        it { _(subject.class.locks_relation_name).must_equal :my_locks }
+        it { _(subject.reflect_on_association(:my_locks).name).must_equal :my_locks }
       end
     end
 
@@ -27,9 +27,9 @@ module MongoidAbility
       let(:other_lock) { MyLock.new(action: :update, subject: MySubject.new) }
       let(:owner) { MyOwner.new(my_locks: [subject_type_lock, subject_lock]) }
 
-      it { owner.has_lock?(subject_type_lock).must_equal true }
-      it { owner.has_lock?(subject_lock).must_equal true }
-      it { owner.has_lock?(other_lock).must_equal false }
+      it { _(owner.has_lock?(subject_type_lock)).must_equal true }
+      it { _(owner.has_lock?(subject_lock)).must_equal true }
+      it { _(owner.has_lock?(other_lock)).must_equal false }
     end
   end
 end

data/test/mongoid_ability/subject_test.rb

@@ -9,8 +9,8 @@ module MongoidAbility
         MySubject1.default_lock MyLock1, :update, false
       end
 
-      it { MySubject.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(read update) }
-      it { MySubject1.default_locks.map(&:action).map(&:to_s).sort.must_equal %w(update) }
+      it { _(MySubject.default_locks.map(&:action).map(&:to_s).sort).must_equal %w(read update) }
+      it { _(MySubject1.default_locks.map(&:action).map(&:to_s).sort).must_equal %w(update) }
     end
 
     describe 'prevents conflicts' do
@@ -20,7 +20,7 @@ module MongoidAbility
           MySubject1.default_lock MyLock, :read, true
         end
 
-        it { MySubject.default_locks.count { |l| l.action == :read }.must_equal 1 }
+        it { _(MySubject.default_locks.count { |l| l.action == :read }).must_equal 1 }
       end
 
       describe 'replace existing locks with new attributes' do
@@ -29,7 +29,7 @@ module MongoidAbility
           MySubject1.default_lock MyLock, :read, true
         end
 
-        it { MySubject.default_locks.detect { |l| l.action == :read }.outcome.must_equal false }
+        it { _(MySubject.default_locks.detect { |l| l.action == :read }.outcome).must_equal false }
       end
 
       describe 'replaces existing locks with new one' do
@@ -38,7 +38,7 @@ module MongoidAbility
           MySubject1.default_lock MyLock, :read, true
         end
 
-        it { MySubject.default_locks.detect { |l| l.action == :read }.class.must_equal MyLock1 }
+        it { _(MySubject.default_locks.detect { |l| l.action == :read }.class).must_equal MyLock1 }
       end
 
       describe 'replaces superclass locks' do
@@ -47,21 +47,21 @@ module MongoidAbility
           MySubject1.default_lock MyLock, :read, true
         end
 
-        it { MySubject1.default_locks.count.must_equal 1 }
-        it { MySubject1.default_locks.detect { |l| l.action == :read }.outcome.must_equal true }
+        it { _(MySubject1.default_locks.count).must_equal 1 }
+        it { _(MySubject1.default_locks.detect { |l| l.action == :read }.outcome).must_equal true }
       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 }
+      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 }
+      it { _(MySubject.root_class).must_equal MySubject }
+      it { _(MySubject1.root_class).must_equal MySubject }
+      it { _(MySubject2.root_class).must_equal MySubject }
     end
   end
 end

data/test/support/test_classes/my_flat_subject.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class MyFlatSubject
+  include Mongoid::Document
+  include MongoidAbility::Subject
+
+  field :str_val, type: String
+  field :override, type: Boolean, default: false
+end

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'bundler/setup'
-require 'database_cleaner'
+require 'database_cleaner/mongoid'
 require 'minitest'
 require 'minitest/autorun'
 require 'minitest/spec'
@@ -9,10 +9,10 @@ require 'mongoid_ability'
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
-if ENV['CI']
-  require 'coveralls'
-  Coveralls.wear!
-end
+# if ENV['CI']
+#   require 'coveralls'
+#   Coveralls.wear!
+# end
 
 Mongoid.logger.level = Logger::INFO
 Mongo::Logger.logger.level = Logger::INFO
@@ -21,16 +21,13 @@ Mongoid.configure do |config|
   config.connect_to('mongoid_ability_test')
 end
 
-DatabaseCleaner.orm = :mongoid
-DatabaseCleaner.strategy = :truncation
-
-class MiniTest::Spec
+class Minitest::Spec
   before(:each) do
     DatabaseCleaner.start
   end
 
   after(:each) do
-    [ MySubject, 
+    [ MySubject,
       MySubject1, MySubject2,
       MySubject11, MySubject21
     ].each(&:reset_default_locks!)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_ability
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.2
 platform: ruby
 authors:
 - Tomas Celizna
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-10-12 00:00:00.000000000 Z
+date: 2023-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancancan
@@ -28,24 +28,18 @@ dependencies:
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '7.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '7.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -59,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -73,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: database_cleaner
+  name: database_cleaner-mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -132,16 +126,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 description: Custom Ability class that allows CanCanCan authorization library store
   permissions in MongoDB via the Mongoid gem.
 email:
@@ -151,14 +145,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".coveralls.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".travis.yml"
+- Appraisals
 - CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- gemfiles/7_0.gemfile
+- gemfiles/7_1.gemfile
+- gemfiles/7_2.gemfile
+- gemfiles/7_3.gemfile
+- gemfiles/7_4.gemfile
+- gemfiles/7_5.gemfile
+- gemfiles/8_0.gemfile
+- gemfiles/8_1.gemfile
 - lib/cancancan/model_adapters/mongoid_adapter.rb
 - lib/cancancan/model_additions.rb
 - lib/mongoid_ability.rb
@@ -183,6 +187,7 @@ files:
 - test/mongoid_ability/owner_test.rb
 - test/mongoid_ability/subject_test.rb
 - test/support/expectations.rb
+- test/support/test_classes/my_flat_subject.rb
 - test/support/test_classes/my_lock.rb
 - test/support/test_classes/my_owner.rb
 - test/support/test_classes/my_role.rb
@@ -192,7 +197,7 @@ homepage: https://github.com/tomasc/mongoid_ability
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -207,9 +212,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.4.6
+signing_key:
 specification_version: 4
 summary: Custom Ability class that allows CanCanCan authorization library store permissions
   in MongoDB via the Mongoid gem.
@@ -227,6 +231,7 @@ test_files:
 - test/mongoid_ability/owner_test.rb
 - test/mongoid_ability/subject_test.rb
 - test/support/expectations.rb
+- test/support/test_classes/my_flat_subject.rb
 - test/support/test_classes/my_lock.rb
 - test/support/test_classes/my_owner.rb
 - test/support/test_classes/my_role.rb