mongoid_archival 0.1.0

data/spec/mongoid/protected_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Mongoid::Archivable::Protected do
+
+  let(:sport) do
+    Sport.create
+  end
+
+  describe '#delete and #delete!' do
+
+    context 'when the document is a root' do
+
+      it 'prevents delete' do
+        expect { sport.delete }.to raise_error(RuntimeError)
+      end
+
+      it 'allows delete!' do
+        sport.delete!
+        expect { sport.reload }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    # context 'when the document is embedded' do
+    # end
+  end
+
+  describe '#destroy and #destroy!' do
+
+    context 'when the document is a root' do
+
+      it 'prevents destroy' do
+        expect { sport.destroy }.to raise_error(RuntimeError)
+      end
+
+      it 'allows destroy!' do
+        sport.destroy!
+        expect { sport.reload }.to raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+    end
+
+    # context 'when the document is embedded' do
+    # end
+  end
+end

data/spec/mongoid/restore_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+RSpec.describe 'Mongoid::Archivable#restore' do
+
+  describe '#restore' do
+
+    context 'when the document is a root' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'testing')
+      end
+
+      before do
+        post.archive
+        post.restore
+      end
+
+      it 'removes the archived at time' do
+        expect(post.archived_at).to be_nil
+      end
+
+      it 'persists the change' do
+        expect(post.reload.archived_at).to be_nil
+      end
+
+      it 'marks document again as persisted' do
+        expect(post.persisted?).to be_truthy
+      end
+
+      context 'will run callback' do
+
+        it 'before restore' do
+          expect(post.before_restore_called).to be_truthy
+        end
+
+        it 'after restore' do
+          expect(post.after_restore_called).to be_truthy
+        end
+
+        it 'around restore' do
+          expect(post.around_before_restore_called).to be_truthy
+          expect(post.around_after_restore_called).to be_truthy
+        end
+      end
+    end
+
+    context 'when the document is embedded' do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.archivable_phones.create(number: '911')
+      end
+
+      before do
+        phone.archive
+        phone.restore
+      end
+
+      it 'removes the archived at time' do
+        expect(phone.archived_at).to be_nil
+      end
+
+      it 'persists the change' do
+        expect(person.reload.archivable_phones.first.archived_at).to be_nil
+      end
+    end
+  end
+
+  describe '#restore_relations' do
+
+    subject { ArchBase.create }
+
+    let!(:arch_has_one)     { subject.arch_has_one = ArchHasOne.create       }
+    let!(:arch_has_many)    { 2.times.map { subject.arch_has_many.create }   }
+    let!(:arch_habtm)       { 3.times.map { subject.arch_habtm.create }      }
+    let!(:arch_belongs_to)  { subject.arch_belongs_to = ArchBelongsTo.create }
+    let!(:arch_embeds_one)  { subject.arch_embeds_one = ArchEmbedsOne.new    }
+    let!(:arch_embeds_many) { 2.times.map { subject.arch_embeds_many.build } }
+
+    let!(:norm_has_one)     { subject.norm_has_one = NormHasOne.create       }
+    let!(:norm_has_many)    { 2.times.map { subject.norm_has_many.create }   }
+    let!(:norm_habtm)       { 3.times.map { subject.norm_habtm.create }      }
+    let!(:norm_belongs_to)  { subject.norm_belongs_to = NormBelongsTo.create }
+    let!(:norm_embeds_one)  { subject.norm_embeds_one = NormEmbedsOne.new    }
+    let!(:norm_embeds_many) { 2.times.map { subject.norm_embeds_many.build } }
+
+    let(:prepare) do
+      subject.archive
+      subject.restore
+    end
+
+    context 'restores archivable associations' do
+      before { prepare }
+
+      it do
+        subject.restore_relations
+      end
+
+      it { expect { subject.restore_relations }.to change { ArchHasOne.current.count    }.by(1) }
+      it { expect { subject.restore_relations }.to change { ArchHasMany.current.count   }.by(2) }
+      it { expect { subject.restore_relations }.to change { ArchHabtm.current.count     }.by(3) }
+      it { expect { subject.restore_relations }.to change { ArchBelongsTo.current.count }.by(1) }
+    end
+
+    context 'does not affect embedded archivable documents' do
+      before { prepare }
+
+      it { expect{ subject.restore_relations}.to_not change{ subject.arch_embeds_one } }
+      it { expect{ subject.restore_relations}.to_not change{ subject.arch_embeds_many.current.count } }
+    end
+
+    context 'does not affect non-archivable documents' do
+      before { prepare }
+
+      it { expect{ subject.restore_relations}.to_not change{ NormHasOne.count    } }
+      it { expect{ subject.restore_relations}.to_not change{ NormHasMany.count   } }
+      it { expect{ subject.restore_relations}.to_not change{ NormHabtm.count     } }
+      it { expect{ subject.restore_relations}.to_not change{ NormBelongsTo.count } }
+      it { expect{ subject.restore_relations}.to_not change{ subject.norm_embeds_one } }
+      it { expect{ subject.restore_relations}.to_not change{ subject.norm_embeds_many.count } }
+    end
+
+    context 'recursion' do
+      let!(:arch_habtm_norm_has_one)  { subject.arch_habtm.first.norm_has_one = NormHasOne.create  } # not restored
+      let!(:arch_habtm_arch_has_one)  { subject.arch_habtm.first.arch_has_one = ArchHasOne.create  } # restored
+      let!(:arch_habtm_norm_has_many) { 2.times.map { subject.arch_habtm.first.norm_has_many  = NormHasMany.create } } # not restored
+      let!(:arch_habtm_arch_has_many) { 3.times.map { subject.arch_habtm.second.arch_has_many = ArchHasMany.create } } # restored
+
+      before do
+        subject.archive
+        subject.restore
+      end
+
+      it { expect { subject.restore_relations}.to change { ArchHasOne.current.count  }.by(2) }
+      it { expect { subject.restore_relations}.to change { ArchHasMany.current.count }.by(3) }
+      it { expect { subject.restore_relations }.to_not change { NormHasOne.count  } }
+      it { expect { subject.restore_relations }.to_not change { NormHasMany.count } }
+      it { expect { subject.restore_relations }.to_not change { NormHabtm.count   } }
+    end
+  end
+end

data/spec/mongoid/scopes_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+RSpec.describe 'Mongoid::Archivable scopes' do
+
+  context 'when the document is archivable' do
+
+    context 'when calling a class method' do
+
+      let(:criteria) do
+        Fish.fresh
+      end
+
+      it 'includes the archived_at criteria in the selector' do
+        expect(criteria.selector).to eq({ 'fresh' => true })
+      end
+    end
+
+    context 'when chaining a class method to unscoped' do
+
+      let(:criteria) do
+        Fish.unscoped.fresh
+      end
+
+      it 'does not include the archived_at in the selector' do
+        expect(criteria.selector).to eq({ 'fresh' => true })
+      end
+    end
+
+    context 'when chaining a class method to archived' do
+
+      let(:criteria) do
+        Fish.archived.fresh
+      end
+
+      it 'includes the archived_at $ne criteria in the selector' do
+        expect(criteria.selector).to eq({
+          'archived_at' => { '$ne' => nil }, 'fresh' => true
+        })
+      end
+    end
+
+    context 'when chaining a where to unscoped' do
+
+      let(:criteria) do
+        Fish.unscoped.where(fresh: true)
+      end
+
+      it 'includes no default scoping information in the selector' do
+        expect(criteria.selector).to eq({ 'fresh' => true })
+      end
+    end
+  end
+
+  describe '.scoped' do
+
+    it 'returns a scoped criteria' do
+      expect(ArchivablePost.scoped.selector).to eq({})
+    end
+  end
+
+  describe '.archived' do
+
+    context 'when called on a root document' do
+
+      let(:post) do
+        ArchivablePost.create(title: 'testing')
+      end
+
+      before do
+        post.archive
+      end
+
+      let(:archived) do
+        ArchivablePost.archived
+      end
+
+      it 'returns the archived documents' do
+        expect(archived).to eq([ post ])
+      end
+    end
+
+    context 'when called on an embedded document' do
+
+      let(:person) do
+        Person.create
+      end
+
+      let(:phone) do
+        person.archivable_phones.create
+      end
+
+      before do
+        phone.archive
+        person.reload
+      end
+
+      it 'returns the archived documents' do
+        expect(person.archivable_phones.archived.to_a).to eq([ phone ])
+      end
+
+      it 'returns the correct count' do
+        expect(person.archivable_phones.archived.count).to eq(1)
+      end
+    end
+  end
+
+  describe '.unscoped' do
+
+    let(:unscoped) do
+      ArchivablePost.unscoped
+    end
+
+    it 'returns an unscoped criteria' do
+      expect(unscoped.selector).to eq({})
+    end
+  end
+end

data/spec/mongoid/validatable/uniqueness_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+RSpec.describe 'Mongoid::Archivable uniqueness validator' do
+
+  describe '#valid?' do
+
+    context 'when the document is a root document' do
+
+      context 'when the document is archivable' do
+        before do
+          ArchivablePost.validates(:title, uniqueness: { conditions: -> { ArchivablePost.where(archived_at: nil) } })
+        end
+
+        after do
+          ArchivablePost.reset_callbacks(:validate)
+        end
+
+        let!(:post) do
+          ArchivablePost.create(title: 'testing')
+        end
+
+        context 'when the field is unique' do
+
+          let(:new_post) do
+            ArchivablePost.new(title: 'test')
+          end
+
+          it 'returns true' do
+            expect(new_post).to be_valid
+          end
+        end
+
+        context 'when the field is unique for non archived docs' do
+
+          before do
+            post.delete
+          end
+
+          let(:new_post) do
+            ArchivablePost.new(title: 'testing')
+          end
+
+          it 'returns true' do
+            expect(new_post).to be_valid
+          end
+        end
+
+        context 'when the field is not unique for archived docs' do
+
+          before do
+            post = ArchivablePost.create(title: 'test')
+            post.archive
+          end
+
+          let(:new_post) do
+            ArchivablePost.new(title: 'test')
+          end
+
+          it 'returns true' do
+            expect(new_post).to be_valid
+          end
+        end
+
+        context 'when the field is not unique' do
+
+          let(:new_post) do
+            ArchivablePost.new(title: 'testing')
+          end
+
+          it 'returns false' do
+            expect(new_post).not_to be_valid
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mongoid'
+require 'mongoid_archival'
+require 'rspec'
+
+# When testing locally we use the database named mongoid_test. However when
+# tests are running in parallel on Travis we need to use different database
+# names for each process running since we do not have transactions and want a
+# clean slate before each spec run.
+def database_id
+  'mongoid_archival_test'
+end
+
+# Set the database that the spec suite connects to.
+Mongoid.configure do |config|
+  config.belongs_to_required_by_default = false
+  config.connect_to(database_id)
+end
+
+RSpec.configure do |config|
+
+  # Drop all collections
+  config.before(:each) do
+    Mongoid.purge!
+  end
+
+  config.before(:all) do
+    Mongoid.logger.level = Logger::INFO
+    Mongo::Logger.logger.level = Logger::INFO
+  end
+
+  config.after(:all) do
+    Mongoid.purge!
+  end
+end
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.singular('address_components', 'address_component')
+end
+
+Dir[File.join(File.dirname(__FILE__), 'app/models/*.rb')].each {|f| require(f) }

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_archival
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Durran Jordan
+- Josef Šimánek
+- Johnny Shields
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+description: Enables archiving (soft delete) of Mongoid documents.
+email:
+- durran@gmail.com
+- retro@ballgag.cz
+- info@tablecheck.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/mongoid/archivable.rb
+- lib/mongoid/archivable/configuration.rb
+- lib/mongoid/archivable/depending.rb
+- lib/mongoid/archivable/protected.rb
+- lib/mongoid/archivable/version.rb
+- lib/mongoid_archival.rb
+- perf/scope.rb
+- spec/app/models/address.rb
+- spec/app/models/appointment.rb
+- spec/app/models/archivable_phone.rb
+- spec/app/models/archivable_post.rb
+- spec/app/models/author.rb
+- spec/app/models/fish.rb
+- spec/app/models/person.rb
+- spec/app/models/phone.rb
+- spec/app/models/relations.rb
+- spec/app/models/sport.rb
+- spec/app/models/tag.rb
+- spec/app/models/title.rb
+- spec/mongoid/archive_spec.rb
+- spec/mongoid/configuration_spec.rb
+- spec/mongoid/document_spec.rb
+- spec/mongoid/nested_attributes_spec.rb
+- spec/mongoid/protected_spec.rb
+- spec/mongoid/restore_spec.rb
+- spec/mongoid/scopes_spec.rb
+- spec/mongoid/validatable/uniqueness_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tablecheck/mongoid_archival
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Archivable documents
+test_files:
+- perf/scope.rb
+- spec/app/models/address.rb
+- spec/app/models/appointment.rb
+- spec/app/models/archivable_phone.rb
+- spec/app/models/archivable_post.rb
+- spec/app/models/author.rb
+- spec/app/models/fish.rb
+- spec/app/models/person.rb
+- spec/app/models/phone.rb
+- spec/app/models/relations.rb
+- spec/app/models/sport.rb
+- spec/app/models/tag.rb
+- spec/app/models/title.rb
+- spec/mongoid/archive_spec.rb
+- spec/mongoid/configuration_spec.rb
+- spec/mongoid/document_spec.rb
+- spec/mongoid/nested_attributes_spec.rb
+- spec/mongoid/protected_spec.rb
+- spec/mongoid/restore_spec.rb
+- spec/mongoid/scopes_spec.rb
+- spec/mongoid/validatable/uniqueness_spec.rb
+- spec/spec_helper.rb