acts_as_paranoid 0.5.0 → 0.7.0

data/lib/acts_as_paranoid/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
   module Relation
     def self.included(base)

data/lib/acts_as_paranoid/validations.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/array/wrap'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/wrap"
 
 module ActsAsParanoid
   module Validations
@@ -6,76 +8,17 @@ module ActsAsParanoid
       base.extend ClassMethods
     end
 
-    class UniquenessWithoutDeletedValidator
-      def self.[](version)
-        version = version.to_s
-        name = "V#{version.tr('.', '_')}"
-        unless constants.include? name.to_sym
-          raise "Unknown validator version #{version.inspect}; expected one of #{constants.sort.join(', ')}"
-        end
-        const_get name
-      end
-
-      class V5 < ActiveRecord::Validations::UniquenessValidator
-        def validate_each(record, attribute, value)
-          finder_class = find_finder_class_for(record)
-          table = finder_class.arel_table
-
-          coder = record.class.attribute_types[attribute.to_s]
-          value = coder.type_cast_for_schema value if value && coder
-
-          relation = build_relation(finder_class, table, attribute, value)
-          [Array(finder_class.primary_key), Array(record.send(:id))].transpose.each do |pk_key, pk_value|
-            relation = relation.where(table[pk_key.to_sym].not_eq(pk_value))
-          end if record.persisted?
-
-          Array.wrap(options[:scope]).each do |scope_item|
-            relation = relation.where(table[scope_item].eq(record.public_send(scope_item)))
-          end
-
-          if relation.where(finder_class.paranoid_default_scope).where(relation).exists?
-            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-          end
-        end
-      end
-
-      class V4 < ActiveRecord::Validations::UniquenessValidator
-        def validate_each(record, attribute, value)
-          finder_class = find_finder_class_for(record)
-          table = finder_class.arel_table
-
-          # TODO: Use record.class.column_types[attribute.to_s].coder ?
-          coder = record.class.column_types[attribute.to_s]
-
-          if value && coder
-            value = if coder.respond_to? :type_cast_for_database
-                      coder.type_cast_for_database value
-                    else
-                      coder.type_cast_for_write value
-                    end
-          end
-
-          relation = build_relation(finder_class, table, attribute, value)
-          [Array(finder_class.primary_key), Array(record.send(:id))].transpose.each do |pk_key, pk_value|
-            relation = relation.and(table[pk_key.to_sym].not_eq(pk_value))
-          end if record.persisted?
-
-          Array.wrap(options[:scope]).each do |scope_item|
-            scope_value = record.send(scope_item)
-            relation = relation.and(table[scope_item].eq(scope_value))
-          end
+    class UniquenessWithoutDeletedValidator < ActiveRecord::Validations::UniquenessValidator
+      private
 
-          # Re-add ActsAsParanoid default scope conditions manually.
-          if finder_class.unscoped.where(finder_class.paranoid_default_scope).where(relation).exists?
-            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-          end
-        end
+      def build_relation(klass, attribute, value)
+        super.where(klass.paranoid_default_scope)
       end
     end
 
     module ClassMethods
       def validates_uniqueness_of_without_deleted(*attr_names)
-        validates_with UniquenessWithoutDeletedValidator[ActiveRecord::VERSION::MAJOR], _merge_attributes(attr_names)
+        validates_with UniquenessWithoutDeletedValidator, _merge_attributes(attr_names)
       end
     end
   end

data/lib/acts_as_paranoid/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActsAsParanoid
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/test/test_associations.rb

@@ -1,27 +1,34 @@
-require 'test_helper'
+# frozen_string_literal: true
+
+require "test_helper"
 
 class AssociationsTest < ParanoidBaseTest
-  def test_removal_with_associations
-    paranoid_company_1 = ParanoidDestroyCompany.create! :name => "ParanoidDestroyCompany #1"
-    paranoid_company_2 = ParanoidDeleteCompany.create! :name => "ParanoidDestroyCompany #1"
-    paranoid_company_1.paranoid_products.create! :name => "ParanoidProduct #1"
-    paranoid_company_2.paranoid_products.create! :name => "ParanoidProduct #2"
+  def test_removal_with_destroy_associations
+    paranoid_company = ParanoidDestroyCompany.create! name: "ParanoidDestroyCompany #1"
+    paranoid_company.paranoid_products.create! name: "ParanoidProduct #1"
 
     assert_equal 1, ParanoidDestroyCompany.count
-    assert_equal 1, ParanoidDeleteCompany.count
-    assert_equal 2, ParanoidProduct.count
+    assert_equal 1, ParanoidProduct.count
 
     ParanoidDestroyCompany.first.destroy
     assert_equal 0, ParanoidDestroyCompany.count
-    assert_equal 1, ParanoidProduct.count
+    assert_equal 0, ParanoidProduct.count
     assert_equal 1, ParanoidDestroyCompany.with_deleted.count
-    assert_equal 2, ParanoidProduct.with_deleted.count
+    assert_equal 1, ParanoidProduct.with_deleted.count
 
     ParanoidDestroyCompany.with_deleted.first.destroy
     assert_equal 0, ParanoidDestroyCompany.count
-    assert_equal 1, ParanoidProduct.count
+    assert_equal 0, ParanoidProduct.count
     assert_equal 0, ParanoidDestroyCompany.with_deleted.count
-    assert_equal 1, ParanoidProduct.with_deleted.count
+    assert_equal 0, ParanoidProduct.with_deleted.count
+  end
+
+  def test_removal_with_delete_all_associations
+    paranoid_company = ParanoidDeleteCompany.create! name: "ParanoidDestroyCompany #1"
+    paranoid_company.paranoid_products.create! name: "ParanoidProduct #2"
+
+    assert_equal 1, ParanoidDeleteCompany.count
+    assert_equal 1, ParanoidProduct.count
 
     ParanoidDeleteCompany.first.destroy
     assert_equal 0, ParanoidDeleteCompany.count
@@ -38,64 +45,122 @@ class AssociationsTest < ParanoidBaseTest
 
   def test_belongs_to_with_scope_option
     paranoid_has_many_dependant = ParanoidHasManyDependant.new
+
+    expected_includes_values = ParanoidTime.includes(:not_paranoid).includes_values
+    includes_values = paranoid_has_many_dependant
+      .association(:paranoid_time_with_scope).scope.includes_values
+
+    assert_equal expected_includes_values, includes_values
+
+    paranoid_time = ParanoidTime.create(name: "not-hello")
+    paranoid_has_many_dependant.paranoid_time = paranoid_time
+    paranoid_has_many_dependant.save!
+
+    assert_nil paranoid_has_many_dependant.paranoid_time_with_scope
+
+    paranoid_time.update(name: "hello")
+
+    paranoid_has_many_dependant.reload
+
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_scope
+
+    paranoid_time.destroy
+
+    paranoid_has_many_dependant.reload
+
+    assert_nil paranoid_has_many_dependant.paranoid_time_with_scope
+  end
+
+  def test_belongs_to_with_scope_and_deleted_option
+    paranoid_has_many_dependant = ParanoidHasManyDependant.new
     includes_values = ParanoidTime.includes(:not_paranoid).includes_values
 
-    assert_equal includes_values, paranoid_has_many_dependant.association(:paranoid_time_with_scope).scope.includes_values
+    assert_equal includes_values, paranoid_has_many_dependant
+      .association(:paranoid_time_with_scope_with_deleted).scope.includes_values
+
+    paranoid_time = ParanoidTime.create(name: "not-hello")
+    paranoid_has_many_dependant.paranoid_time = paranoid_time
+    paranoid_has_many_dependant.save!
+
+    assert_nil paranoid_has_many_dependant.paranoid_time_with_scope_with_deleted
+
+    paranoid_time.update(name: "hello")
+    paranoid_has_many_dependant.reload
+
+    assert_equal paranoid_time, paranoid_has_many_dependant
+      .paranoid_time_with_scope_with_deleted
+
+    paranoid_time.destroy
+    paranoid_has_many_dependant.reload
+
+    assert_equal paranoid_time, paranoid_has_many_dependant
+      .paranoid_time_with_scope_with_deleted
   end
 
   def test_belongs_to_with_deleted
     paranoid_time = ParanoidTime.first
-    paranoid_has_many_dependant = paranoid_time.paranoid_has_many_dependants.create(:name => 'dependant!')
+    paranoid_has_many_dependant = paranoid_time.paranoid_has_many_dependants
+      .create(name: "dependant!")
 
     assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time
     assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted
 
     paranoid_time.destroy
+    paranoid_has_many_dependant.reload
 
-    assert_nil paranoid_has_many_dependant.paranoid_time(true)
-    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted(true)
+    assert_nil paranoid_has_many_dependant.paranoid_time
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted
   end
 
   def test_belongs_to_polymorphic_with_deleted
     paranoid_time = ParanoidTime.first
-    paranoid_has_many_dependant = ParanoidHasManyDependant.create!(:name => 'dependant!', :paranoid_time_polymorphic_with_deleted => paranoid_time)
+    paranoid_has_many_dependant = ParanoidHasManyDependant
+      .create!(name: "dependant!", paranoid_time_polymorphic_with_deleted: paranoid_time)
 
     assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time
-    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted
+    assert_equal paranoid_time, paranoid_has_many_dependant
+      .paranoid_time_polymorphic_with_deleted
 
     paranoid_time.destroy
 
-    assert_nil paranoid_has_many_dependant.paranoid_time(true)
-    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted(true)
+    assert_nil paranoid_has_many_dependant.reload.paranoid_time
+    assert_equal paranoid_time, paranoid_has_many_dependant
+      .reload.paranoid_time_polymorphic_with_deleted
   end
 
   def test_belongs_to_nil_polymorphic_with_deleted
     paranoid_time = ParanoidTime.first
-    paranoid_has_many_dependant = ParanoidHasManyDependant.create!(:name => 'dependant!', :paranoid_time_polymorphic_with_deleted => nil)
+    paranoid_has_many_dependant =
+      ParanoidHasManyDependant.create!(name: "dependant!",
+                                       paranoid_time_polymorphic_with_deleted: nil)
 
     assert_nil paranoid_has_many_dependant.paranoid_time
     assert_nil paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted
 
     paranoid_time.destroy
 
-    assert_nil paranoid_has_many_dependant.paranoid_time(true)
-    assert_nil paranoid_has_many_dependant.paranoid_time_polymorphic_with_deleted(true)
+    assert_nil paranoid_has_many_dependant.reload.paranoid_time
+    assert_nil paranoid_has_many_dependant.reload.paranoid_time_polymorphic_with_deleted
   end
 
   def test_belongs_to_options
-    paranoid_time = ParanoidHasManyDependant.reflections.with_indifferent_access[:paranoid_time]
+    paranoid_time = ParanoidHasManyDependant.reflections
+      .with_indifferent_access[:paranoid_time]
     assert_equal :belongs_to, paranoid_time.macro
     assert_nil paranoid_time.options[:with_deleted]
   end
 
   def test_belongs_to_with_deleted_options
-    paranoid_time_with_deleted = ParanoidHasManyDependant.reflections.with_indifferent_access[:paranoid_time_with_deleted]
+    paranoid_time_with_deleted =
+      ParanoidHasManyDependant.reflections
+        .with_indifferent_access[:paranoid_time_with_deleted]
     assert_equal :belongs_to, paranoid_time_with_deleted.macro
     assert paranoid_time_with_deleted.options[:with_deleted]
   end
 
   def test_belongs_to_polymorphic_with_deleted_options
-    paranoid_time_polymorphic_with_deleted = ParanoidHasManyDependant.reflections.with_indifferent_access[:paranoid_time_polymorphic_with_deleted]
+    paranoid_time_polymorphic_with_deleted = ParanoidHasManyDependant.reflections
+      .with_indifferent_access[:paranoid_time_polymorphic_with_deleted]
     assert_equal :belongs_to, paranoid_time_polymorphic_with_deleted.macro
     assert paranoid_time_polymorphic_with_deleted.options[:with_deleted]
   end
@@ -118,6 +183,50 @@ class AssociationsTest < ParanoidBaseTest
     assert_equal [child], parent.paranoid_has_many_dependants.with_deleted.to_a
   end
 
+  def test_join_with_model_with_deleted
+    obj = ParanoidHasManyDependant.create(paranoid_time: ParanoidTime.create)
+    assert_not_nil obj.paranoid_time
+    assert_not_nil obj.paranoid_time_with_deleted
+
+    obj.paranoid_time.destroy
+    obj.reload
+
+    assert_nil obj.paranoid_time
+    assert_not_nil obj.paranoid_time_with_deleted
+
+    # Note that obj is destroyed because of dependent: :destroy in ParanoidTime
+    assert obj.destroyed?
+
+    assert_empty ParanoidHasManyDependant.with_deleted.joins(:paranoid_time)
+    assert_equal [obj],
+                 ParanoidHasManyDependant.with_deleted.joins(:paranoid_time_with_deleted)
+  end
+
+  def test_includes_with_deleted
+    paranoid_time = ParanoidTime.first
+    paranoid_time.paranoid_has_many_dependants.create(name: "dependant!")
+
+    paranoid_time.destroy
+
+    ParanoidHasManyDependant.with_deleted
+      .includes(:paranoid_time_with_deleted).each do |hasmany|
+      assert_not_nil hasmany.paranoid_time_with_deleted
+    end
+  end
+
+  def test_includes_with_deleted_with_polymorphic_parent
+    not_paranoid_parent = NotParanoidHasManyAsParent.create(name: "not paranoid parent")
+    paranoid_parent = ParanoidHasManyAsParent.create(name: "paranoid parent")
+    ParanoidBelongsToPolymorphic.create(name: "belongs_to", parent: not_paranoid_parent)
+    ParanoidBelongsToPolymorphic.create(name: "belongs_to", parent: paranoid_parent)
+
+    paranoid_parent.destroy
+
+    ParanoidBelongsToPolymorphic.with_deleted.includes(:parent).each do |hasmany|
+      assert_not_nil hasmany.parent
+    end
+  end
+
   def test_cannot_find_a_paranoid_deleted_many_many_association
     left = ParanoidManyManyParentLeft.create
     right = ParanoidManyManyParentRight.create
@@ -128,8 +237,10 @@ class AssociationsTest < ParanoidBaseTest
     left.reload
 
     assert_equal [], left.paranoid_many_many_children, "Linking objects not deleted"
-    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not unlinked"
-    assert_equal right, ParanoidManyManyParentRight.find(right.id), "Associated object deleted"
+    assert_equal [], left.paranoid_many_many_parent_rights,
+                 "Associated objects not unlinked"
+    assert_equal right, ParanoidManyManyParentRight.find(right.id),
+                 "Associated object deleted"
   end
 
   def test_cannot_find_a_paranoid_destroyed_many_many_association
@@ -142,11 +253,13 @@ class AssociationsTest < ParanoidBaseTest
     left.reload
 
     assert_equal [], left.paranoid_many_many_children, "Linking objects not deleted"
-    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not unlinked"
-    assert_equal right, ParanoidManyManyParentRight.find(right.id), "Associated object deleted"
+    assert_equal [], left.paranoid_many_many_parent_rights,
+                 "Associated objects not unlinked"
+    assert_equal right, ParanoidManyManyParentRight.find(right.id),
+                 "Associated object deleted"
   end
 
-  def test_cannot_find_a_has_many_through_object_when_its_linking_object_is_paranoid_destroyed
+  def test_cannot_find_a_has_many_through_object_when_its_linking_object_is_soft_destroyed
     left = ParanoidManyManyParentLeft.create
     right = ParanoidManyManyParentRight.create
     left.paranoid_many_many_parent_rights << right
@@ -175,8 +288,10 @@ class AssociationsTest < ParanoidBaseTest
     left.paranoid_many_many_parent_rights << right
 
     child = left.paranoid_many_many_children.first
-    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
-    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+    assert_equal left, child.paranoid_many_many_parent_left,
+                 "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right,
+                 "Child's right parent is incorrect"
 
     left.paranoid_many_many_parent_rights.clear
 
@@ -189,8 +304,10 @@ class AssociationsTest < ParanoidBaseTest
     left.paranoid_many_many_parent_rights << right
 
     child = left.paranoid_many_many_children.first
-    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
-    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+    assert_equal left, child.paranoid_many_many_parent_left,
+                 "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right,
+                 "Child's right parent is incorrect"
 
     left.paranoid_many_many_parent_rights.destroy(right)
 
@@ -203,8 +320,10 @@ class AssociationsTest < ParanoidBaseTest
     left.paranoid_many_many_parent_rights << right
 
     child = left.paranoid_many_many_children.first
-    assert_equal left, child.paranoid_many_many_parent_left, "Child's left parent is incorrect"
-    assert_equal right, child.paranoid_many_many_parent_right, "Child's right parent is incorrect"
+    assert_equal left, child.paranoid_many_many_parent_left,
+                 "Child's left parent is incorrect"
+    assert_equal right, child.paranoid_many_many_parent_right,
+                 "Child's right parent is incorrect"
 
     left.paranoid_many_many_parent_rights.delete(right)
 
@@ -228,9 +347,12 @@ class AssociationsTest < ParanoidBaseTest
   end
 
   def test_mass_assignment_of_paranoid_column_enabled
+    if Gem.loaded_specs["activerecord"].version >= Gem::Version.new("5.2.0")
+      skip "Creation as deleted is not supported with Rails >= 5.2"
+    end
     now = Time.now
-    record = ParanoidTime.create! :name => 'Foo', :deleted_at => now
-    assert_equal 'Foo', record.name
+    record = ParanoidTime.create! name: "Foo", deleted_at: now
+    assert_equal "Foo", record.name
     assert_equal now, record.deleted_at
   end
 end

data/test/test_core.rb

@@ -1,4 +1,6 @@
-require 'test_helper'
+# frozen_string_literal: true
+
+require "test_helper"
 
 class ParanoidTest < ParanoidBaseTest
   def test_paranoid?
@@ -69,6 +71,13 @@ class ParanoidTest < ParanoidBaseTest
     assert_not_nil pt.paranoid_value
   end
 
+  def test_non_persisted_delete
+    pt = ParanoidTime.new
+    assert_nil pt.paranoid_value
+    pt.delete
+    assert_not_nil pt.paranoid_value
+  end
+
   def test_non_persisted_destroy!
     pt = ParanoidTime.new
     assert_nil pt.paranoid_value
@@ -94,12 +103,34 @@ class ParanoidTest < ParanoidBaseTest
     assert_equal 1, ParanoidString.count
   end
 
+  def test_recovery!
+    ParanoidBoolean.first.destroy
+    ParanoidBoolean.create(name: "paranoid")
+
+    assert_raise do
+      ParanoidBoolean.only_deleted.first.recover!
+    end
+  end
+
+  # Rails does not allow saving deleted records
+  def test_no_save_after_destroy
+    paranoid = ParanoidString.first
+    paranoid.destroy
+    paranoid.name = "Let's update!"
+
+    assert_not paranoid.save
+    assert_raises ActiveRecord::RecordNotSaved do
+      paranoid.save!
+    end
+  end
+
   def setup_recursive_tests
     @paranoid_time_object = ParanoidTime.first
 
     # Create one extra ParanoidHasManyDependant record so that we can validate
     # the correct dependants are recovered.
-    ParanoidTime.where('id <> ?', @paranoid_time_object.id).first.paranoid_has_many_dependants.create(:name => "should not be recovered").destroy
+    ParanoidTime.where("id <> ?", @paranoid_time_object.id).first
+      .paranoid_has_many_dependants.create(name: "should not be recovered").destroy
 
     @paranoid_boolean_count = ParanoidBoolean.count
 
@@ -108,20 +139,21 @@ class ParanoidTest < ParanoidBaseTest
     assert_equal 1, NotParanoid.count
 
     (1..3).each do |i|
-      has_many_object = @paranoid_time_object.paranoid_has_many_dependants.create(:name => "has_many_#{i}")
-      has_many_object.create_paranoid_belongs_dependant(:name => "belongs_to_#{i}")
+      has_many_object = @paranoid_time_object.paranoid_has_many_dependants
+        .create(name: "has_many_#{i}")
+      has_many_object.create_paranoid_belongs_dependant(name: "belongs_to_#{i}")
       has_many_object.save
 
-      paranoid_boolean = @paranoid_time_object.paranoid_booleans.create(:name => "boolean_#{i}")
-      paranoid_boolean.create_paranoid_has_one_dependant(:name => "has_one_#{i}")
+      paranoid_boolean = @paranoid_time_object.paranoid_booleans
+        .create(name: "boolean_#{i}")
+      paranoid_boolean.create_paranoid_has_one_dependant(name: "has_one_#{i}")
       paranoid_boolean.save
 
-      @paranoid_time_object.not_paranoids.create(:name => "not_paranoid_a#{i}")
-
+      @paranoid_time_object.not_paranoids.create(name: "not_paranoid_a#{i}")
     end
 
-    @paranoid_time_object.create_not_paranoid(:name => "not_paranoid_belongs_to")
-    @paranoid_time_object.create_has_one_not_paranoid(:name => "has_one_not_paranoid")
+    @paranoid_time_object.create_not_paranoid(name: "not_paranoid_belongs_to")
+    @paranoid_time_object.create_has_one_not_paranoid(name: "has_one_not_paranoid")
 
     assert_equal 3, ParanoidTime.count
     assert_equal 3, ParanoidHasManyDependant.count
@@ -172,7 +204,7 @@ class ParanoidTest < ParanoidBaseTest
     @paranoid_time_object.destroy
     @paranoid_time_object.reload
 
-    @paranoid_time_object.recover(:recursive => true)
+    @paranoid_time_object.recover(recursive: true)
 
     assert_equal 3, ParanoidTime.count
     assert_equal 3, ParanoidHasManyDependant.count
@@ -186,17 +218,21 @@ class ParanoidTest < ParanoidBaseTest
   def test_recursive_recovery_dependant_window
     setup_recursive_tests
 
-    @paranoid_time_object.destroy
-    @paranoid_time_object.reload
-
     # Stop the following from recovering:
     #   - ParanoidHasManyDependant and its ParanoidBelongsDependant
     #   - A single ParanoidBelongsDependant, but not its parent
-    dependants = @paranoid_time_object.paranoid_has_many_dependants.with_deleted
-    dependants.first.update_attribute(:deleted_at, 2.days.ago)
-    ParanoidBelongsDependant.with_deleted.where(:id => dependants.last.paranoid_belongs_dependant_id).first.update_attribute(:deleted_at, 1.hour.ago)
+    Time.stub :now, 2.days.ago do
+      @paranoid_time_object.paranoid_has_many_dependants.first.destroy
+    end
+    Time.stub :now, 1.hour.ago do
+      @paranoid_time_object.paranoid_has_many_dependants
+        .last.paranoid_belongs_dependant
+        .destroy
+    end
+    @paranoid_time_object.destroy
+    @paranoid_time_object.reload
 
-    @paranoid_time_object.recover(:recursive => true)
+    @paranoid_time_object.recover(recursive: true)
 
     assert_equal 3, ParanoidTime.count
     assert_equal 2, ParanoidHasManyDependant.count
@@ -209,31 +245,31 @@ class ParanoidTest < ParanoidBaseTest
 
   def test_recursive_recovery_for_belongs_to_polymorphic
     child_1 = ParanoidAndroid.create
-    section_1 = ParanoidSection.create(:paranoid_thing => child_1)
+    section_1 = ParanoidSection.create(paranoid_thing: child_1)
 
-    child_2 = ParanoidHuman.create(:gender => 'male')
-    section_2 = ParanoidSection.create(:paranoid_thing => child_2)
+    child_2 = ParanoidPolygon.create(sides: 3)
+    section_2 = ParanoidSection.create(paranoid_thing: child_2)
 
     assert_equal section_1.paranoid_thing, child_1
     assert_equal section_1.paranoid_thing.class, ParanoidAndroid
     assert_equal section_2.paranoid_thing, child_2
-    assert_equal section_2.paranoid_thing.class, ParanoidHuman
+    assert_equal section_2.paranoid_thing.class, ParanoidPolygon
 
-    parent = ParanoidTime.create(:name => "paranoid_parent")
+    parent = ParanoidTime.create(name: "paranoid_parent")
     parent.paranoid_sections << section_1
     parent.paranoid_sections << section_2
 
     assert_equal 4, ParanoidTime.count
     assert_equal 2, ParanoidSection.count
     assert_equal 1, ParanoidAndroid.count
-    assert_equal 1, ParanoidHuman.count
+    assert_equal 1, ParanoidPolygon.count
 
     parent.destroy
 
     assert_equal 3, ParanoidTime.count
     assert_equal 0, ParanoidSection.count
     assert_equal 0, ParanoidAndroid.count
-    assert_equal 0, ParanoidHuman.count
+    assert_equal 0, ParanoidPolygon.count
 
     parent.reload
     parent.recover
@@ -241,7 +277,7 @@ class ParanoidTest < ParanoidBaseTest
     assert_equal 4, ParanoidTime.count
     assert_equal 2, ParanoidSection.count
     assert_equal 1, ParanoidAndroid.count
-    assert_equal 1, ParanoidHuman.count
+    assert_equal 1, ParanoidPolygon.count
   end
 
   def test_non_recursive_recovery
@@ -250,7 +286,7 @@ class ParanoidTest < ParanoidBaseTest
     @paranoid_time_object.destroy
     @paranoid_time_object.reload
 
-    @paranoid_time_object.recover(:recursive => false)
+    @paranoid_time_object.recover(recursive: false)
 
     assert_equal 3, ParanoidTime.count
     assert_equal 0, ParanoidHasManyDependant.count
@@ -261,6 +297,24 @@ class ParanoidTest < ParanoidBaseTest
     assert_equal 0, HasOneNotParanoid.count
   end
 
+  def test_dirty
+    pt = ParanoidTime.create
+    pt.destroy
+    assert_not pt.changed?
+  end
+
+  def test_delete_dirty
+    pt = ParanoidTime.create
+    pt.delete
+    assert_not pt.changed?
+  end
+
+  def test_destroy_fully_dirty
+    pt = ParanoidTime.create
+    pt.destroy_fully!
+    assert_not pt.changed?
+  end
+
   def test_deleted?
     ParanoidTime.first.destroy
     assert ParanoidTime.with_deleted.first.deleted?
@@ -269,6 +323,43 @@ class ParanoidTest < ParanoidBaseTest
     assert ParanoidString.with_deleted.first.deleted?
   end
 
+  def test_delete_deleted?
+    ParanoidTime.first.delete
+    assert ParanoidTime.with_deleted.first.deleted?
+
+    ParanoidString.first.delete
+    assert ParanoidString.with_deleted.first.deleted?
+  end
+
+  def test_destroy_fully_deleted?
+    object = ParanoidTime.first
+    object.destroy_fully!
+    assert object.deleted?
+
+    object = ParanoidString.first
+    object.destroy_fully!
+    assert object.deleted?
+  end
+
+  def test_deleted_fully?
+    ParanoidTime.first.destroy
+    assert_not ParanoidTime.with_deleted.first.deleted_fully?
+
+    ParanoidString.first.destroy
+    assert ParanoidString.with_deleted.first.deleted?
+  end
+
+  def test_delete_deleted_fully?
+    ParanoidTime.first.delete
+    assert_not ParanoidTime.with_deleted.first.deleted_fully?
+  end
+
+  def test_destroy_fully_deleted_fully?
+    object = ParanoidTime.first
+    object.destroy_fully!
+    assert object.deleted_fully?
+  end
+
   def test_paranoid_destroy_callbacks
     @paranoid_with_callback = ParanoidWithCallback.first
     ParanoidWithCallback.transaction do
@@ -308,6 +399,14 @@ class ParanoidTest < ParanoidBaseTest
     assert @paranoid_with_callback.called_after_recover
   end
 
+  def test_recovery_callbacks_without_destroy
+    @paranoid_with_callback = ParanoidWithCallback.first
+    @paranoid_with_callback.recover
+
+    assert_nil @paranoid_with_callback.called_before_recover
+    assert_nil @paranoid_with_callback.called_after_recover
+  end
+
   def test_delete_by_multiple_id_is_paranoid
     model_a = ParanoidBelongsDependant.create
     model_b = ParanoidBelongsDependant.create
@@ -356,81 +455,179 @@ class ParanoidTest < ParanoidBaseTest
 
   # Test string type columns that don't have a nil value when not deleted (Y/N for example)
   def test_string_type_with_no_nil_value_before_destroy
-    ps = ParanoidString.create!(:deleted => 'not dead')
-    assert_equal 1, ParanoidString.where(:id => ps).count
+    ps = ParanoidString.create!(deleted: "not dead")
+    assert_equal 1, ParanoidString.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_after_destroy
-    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps = ParanoidString.create!(deleted: "not dead")
     ps.destroy
-    assert_equal 0, ParanoidString.where(:id => ps).count
+    assert_equal 0, ParanoidString.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_before_destroy_with_deleted
-    ps = ParanoidString.create!(:deleted => 'not dead')
-    assert_equal 1, ParanoidString.with_deleted.where(:id => ps).count
+    ps = ParanoidString.create!(deleted: "not dead")
+    assert_equal 1, ParanoidString.with_deleted.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_after_destroy_with_deleted
-    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps = ParanoidString.create!(deleted: "not dead")
     ps.destroy
-    assert_equal 1, ParanoidString.with_deleted.where(:id => ps).count
+    assert_equal 1, ParanoidString.with_deleted.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_before_destroy_only_deleted
-    ps = ParanoidString.create!(:deleted => 'not dead')
-    assert_equal 0, ParanoidString.only_deleted.where(:id => ps).count
+    ps = ParanoidString.create!(deleted: "not dead")
+    assert_equal 0, ParanoidString.only_deleted.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_after_destroy_only_deleted
-    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps = ParanoidString.create!(deleted: "not dead")
     ps.destroy
-    assert_equal 1, ParanoidString.only_deleted.where(:id => ps).count
+    assert_equal 1, ParanoidString.only_deleted.where(id: ps).count
   end
 
   def test_string_type_with_no_nil_value_after_destroyed_twice
-    ps = ParanoidString.create!(:deleted => 'not dead')
+    ps = ParanoidString.create!(deleted: "not dead")
     2.times { ps.destroy }
-    assert_equal 0, ParanoidString.with_deleted.where(:id => ps).count
+    assert_equal 0, ParanoidString.with_deleted.where(id: ps).count
   end
 
   # Test boolean type columns, that are not nullable
   def test_boolean_type_with_no_nil_value_before_destroy
-    ps = ParanoidBooleanNotNullable.create!()
-    assert_equal 1, ParanoidBooleanNotNullable.where(:id => ps).count
+    ps = ParanoidBooleanNotNullable.create!
+    assert_equal 1, ParanoidBooleanNotNullable.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_after_destroy
-    ps = ParanoidBooleanNotNullable.create!()
+    ps = ParanoidBooleanNotNullable.create!
     ps.destroy
-    assert_equal 0, ParanoidBooleanNotNullable.where(:id => ps).count
+    assert_equal 0, ParanoidBooleanNotNullable.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_before_destroy_with_deleted
-    ps = ParanoidBooleanNotNullable.create!()
-    assert_equal 1, ParanoidBooleanNotNullable.with_deleted.where(:id => ps).count
+    ps = ParanoidBooleanNotNullable.create!
+    assert_equal 1, ParanoidBooleanNotNullable.with_deleted.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_after_destroy_with_deleted
-    ps = ParanoidBooleanNotNullable.create!()
+    ps = ParanoidBooleanNotNullable.create!
     ps.destroy
-    assert_equal 1, ParanoidBooleanNotNullable.with_deleted.where(:id => ps).count
+    assert_equal 1, ParanoidBooleanNotNullable.with_deleted.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_before_destroy_only_deleted
-    ps = ParanoidBooleanNotNullable.create!()
-    assert_equal 0, ParanoidBooleanNotNullable.only_deleted.where(:id => ps).count
+    ps = ParanoidBooleanNotNullable.create!
+    assert_equal 0, ParanoidBooleanNotNullable.only_deleted.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_after_destroy_only_deleted
-    ps = ParanoidBooleanNotNullable.create!()
+    ps = ParanoidBooleanNotNullable.create!
     ps.destroy
-    assert_equal 1, ParanoidBooleanNotNullable.only_deleted.where(:id => ps).count
+    assert_equal 1, ParanoidBooleanNotNullable.only_deleted.where(id: ps).count
   end
 
   def test_boolean_type_with_no_nil_value_after_destroyed_twice
-    ps = ParanoidBooleanNotNullable.create!()
+    ps = ParanoidBooleanNotNullable.create!
+    2.times { ps.destroy }
+    assert_equal 0, ParanoidBooleanNotNullable.with_deleted.where(id: ps).count
+  end
+
+  def test_no_double_tap_destroys_fully
+    ps = ParanoidNoDoubleTapDestroysFully.create!
     2.times { ps.destroy }
-    assert_equal 0, ParanoidBooleanNotNullable.with_deleted.where(:id => ps).count
+    assert_equal 1, ParanoidNoDoubleTapDestroysFully.with_deleted.where(id: ps).count
+  end
+
+  def test_decrement_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_counter_cache = ParanoidWithCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.paranoid_with_counter_caches_count
+
+    paranoid_with_counter_cache.destroy
+
+    assert_equal 0, paranoid_boolean.reload.paranoid_with_counter_caches_count
+  end
+
+  def test_decrement_custom_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_custom_counter_cache = ParanoidWithCustomCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.custom_counter_cache
+
+    paranoid_with_custom_counter_cache.destroy
+
+    assert_equal 0, paranoid_boolean.reload.custom_counter_cache
+  end
+
+  def test_destroy_with_optional_belongs_to_and_counter_cache
+    ps = ParanoidWithCounterCacheOnOptionalBelognsTo.create!
+    ps.destroy
+    assert_equal 1, ParanoidWithCounterCacheOnOptionalBelognsTo.only_deleted
+      .where(id: ps).count
+  end
+
+  def test_hard_destroy_decrement_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_counter_cache = ParanoidWithCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.paranoid_with_counter_caches_count
+
+    paranoid_with_counter_cache.destroy_fully!
+
+    assert_equal 0, paranoid_boolean.reload.paranoid_with_counter_caches_count
+  end
+
+  def test_hard_destroy_decrement_custom_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_custom_counter_cache = ParanoidWithCustomCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.custom_counter_cache
+
+    paranoid_with_custom_counter_cache.destroy_fully!
+
+    assert_equal 0, paranoid_boolean.reload.custom_counter_cache
+  end
+
+  def test_increment_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_counter_cache = ParanoidWithCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.paranoid_with_counter_caches_count
+
+    paranoid_with_counter_cache.destroy
+
+    assert_equal 0, paranoid_boolean.reload.paranoid_with_counter_caches_count
+
+    paranoid_with_counter_cache.recover
+
+    assert_equal 1, paranoid_boolean.reload.paranoid_with_counter_caches_count
+  end
+
+  def test_increment_custom_counters
+    paranoid_boolean = ParanoidBoolean.create!
+    paranoid_with_custom_counter_cache = ParanoidWithCustomCounterCache
+      .create!(paranoid_boolean: paranoid_boolean)
+
+    assert_equal 1, paranoid_boolean.custom_counter_cache
+
+    paranoid_with_custom_counter_cache.destroy
+
+    assert_equal 0, paranoid_boolean.reload.custom_counter_cache
+
+    paranoid_with_custom_counter_cache.recover
+
+    assert_equal 1, paranoid_boolean.reload.custom_counter_cache
+  end
+
+  def test_explicitly_setting_table_name_after_acts_as_paranoid_macro
+    assert_equal "explicit_table.deleted_at", ParanoidWithExplicitTableNameAfterMacro
+      .paranoid_column_reference
   end
 end