acts_as_paranoid 0.5.0.beta2 → 0.5.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e64b4e62e3467e6208b4b06d4f6f6f45b5758888
-  data.tar.gz: 1bf27545571d18596daa573546c84811da6fc5dd
+  metadata.gz: 124d271ce76db90e3e605685839c061359d22ff6
+  data.tar.gz: 18fd8e01afccccf40e31b722bad341434c2d1899
 SHA512:
-  metadata.gz: 8b4cc3ccb8a881344891c1ded817044c805d3dada173b769725504679c7ab377ce2c078a2f950f093339a8ecd1892532d35777fc8f02231a0fdb8c39e33a5feb
-  data.tar.gz: 15d82db6a8ec57720936cbba69dad58ceb98369d7b273610a7594e40d2ba77d08565603676670591e6c1e8c46ff01b02e6fc869215c0f68a8d5f84a0c0c0a689
+  metadata.gz: 113820d1b627fecfe8167342678b992b39af55758e82e2e5115e4ab9b69831d950fd605cc40cb2668178b37e83b6a0e80b68240a9fbee9b65982eeb365ab0c02
+  data.tar.gz: ddecec89fcc2e85ad58237bac886cc6bf072c28d5bf249cdc4714f3ab356275d0ceee470fafac867966c976452260f8022d53e10e5b750aa7d16fa8a38c9c2be

data/README.md

@@ -8,9 +8,9 @@ This gem can be used to hide records instead of deleting them, making them recov
 
 ## Support
 
-**This branch targets Rails 4.x.**
+**This branch targets Rails 4.x. and 5.x**
 
-If you're working with another version, switch to the corresponding branch, or require an older version of the acts_as_paranoid gem.
+If you're working with another version, switch to the corresponding branch, or require an older version of the `acts_as_paranoid` gem.
 
 ## Usage
 
@@ -37,12 +37,18 @@ The values shown are the defaults. While *column* can be anything (as long as it
 
 If your column type is a `string`, you can also specify which value to use when marking an object as deleted by passing `:deleted_value` (default is "deleted"). Any records with a non-matching value in this column will be treated normally (ie: not deleted).
 
+If your column type is a `boolean`, it is possible to specify `allow_nulls` option which is `true` by default. When set to `false`, entities that have `false` value in this column will be considered not deleted, and those which have `true` will be considered deleted. When `true` everything that has a not-null value will be considered deleted.
+
 ### Filtering
 
-If a record is deleted by ActsAsParanoid, it won't be retrieved when accessing the database. So, `Paranoiac.all` will **not** include the deleted_records. if you want to access them, you have 2 choices:
+If a record is deleted by ActsAsParanoid, it won't be retrieved when accessing the database.
+
+So, `Paranoiac.all` will **not** include the **deleted records**.
+
+When you want to access them, you have 2 choices:
 
 ```ruby
-Paranoiac.only_deleted # retrieves the deleted records
+Paranoiac.only_deleted # retrieves only the deleted records
 Paranoiac.with_deleted # retrieves all records, deleted or not
 ```
 
@@ -67,7 +73,13 @@ paranoiac.destroy!
 Paranoiac.delete_all!(conditions)
 ```
 
-You can also permanently delete a record by calling `destroy` or `delete_all` on it **twice**. If a record was already deleted (hidden by ActsAsParanoid) and you delete it again, it will be removed from the database. Take this example:
+You can also permanently delete a record by calling `destroy_fully!` on the object.
+
+Alternatively you can permanently delete a record by calling `destroy` or `delete_all` on the object **twice**.
+
+If a record was already deleted (hidden by `ActsAsParanoid`) and you delete it again, it will be removed from the database.
+
+Take this example:
 
 ```ruby
 p = Paranoiac.first
@@ -83,7 +95,9 @@ Recovery is easy. Just invoke `recover` on it, like this:
 Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover
 ```
 
-All associations marked as `:dependent => :destroy` are also recursively recovered. If you would like to disable this behavior, you can call `recover` with the `recursive` option:
+All associations marked as `:dependent => :destroy` are also recursively recovered.
+
+If you would like to disable this behavior, you can call `recover` with the `recursive` option:
 
 ```ruby
 Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover(:recursive => false)
@@ -97,7 +111,13 @@ class Paranoiac < ActiveRecord::Base
 end
 ```
 
-By default, dependent records will be recovered if they were deleted within 2 minutes of the object upon which they depend.  This restores the objects to the state before the recursive deletion without restoring other objects that were deleted earlier.  The behavior is only available when both parent and dependant are using timestamp fields to mark deletion, which is the default behavior. This window can be changed with the `dependent_recovery_window` option:
+By default, dependent records will be recovered if they were deleted within 2 minutes of the object upon which they depend.
+
+This restores the objects to the state before the recursive deletion without restoring other objects that were deleted earlier.
+
+The behavior is only available when both parent and dependant are using timestamp fields to mark deletion, which is the default behavior.
+
+This window can be changed with the `dependent_recovery_window` option:
 
 ```ruby
 class Paranoiac < ActiveRecord::Base
@@ -125,9 +145,9 @@ ActiveRecord's built-in uniqueness validation does not account for records delet
 
 ```ruby
 class Paranoiac < ActiveRecord::Base
-    acts_as_paranoid
-  	validates_as_paranoid
-  	validates_uniqueness_of_without_deleted :name
+  acts_as_paranoid
+  validates_as_paranoid
+  validates_uniqueness_of_without_deleted :name
 end
 
 p1 = Paranoiac.create(:name => 'foo')
@@ -150,13 +170,15 @@ Paranoiac.with_deleted.first.deleted? #=> true
 
 ### Scopes
 
-As you've probably guessed, `with_deleted` and `only_deleted` are scopes. You can, however, chain them freely with other scopes you might have. This
+As you've probably guessed, `with_deleted` and `only_deleted` are scopes. You can, however, chain them freely with other scopes you might have.
+
+For example:
 
 ```ruby
 Paranoiac.pretty.with_deleted
 ```
 
-is exactly the same as
+This is exactly the same as:
 
 ```ruby
 Paranoiac.with_deleted.pretty
@@ -166,8 +188,8 @@ You can work freely with scopes and it will just work:
 
 ```ruby
 class Paranoiac < ActiveRecord::Base
-	acts_as_paranoid
-	scope :pretty, where(:pretty => true)
+  acts_as_paranoid
+  scope :pretty, where(:pretty => true)
 end
 
 Paranoiac.create(:pretty => true)
@@ -185,7 +207,9 @@ Paranoiac.pretty.only_deleted.count #=> 1
 
 ### Associations
 
-Associations are also supported. From the simplest behaviors you'd expect to more nifty things like the ones mentioned previously or the usage of the `:with_deleted` option with `belongs_to`
+Associations are also supported.
+
+From the simplest behaviors you'd expect to more nifty things like the ones mentioned previously or the usage of the `:with_deleted` option with `belongs_to`
 
 ```ruby
 class Parent < ActiveRecord::Base
@@ -197,7 +221,7 @@ class ParanoiacChild < ActiveRecord::Base
   belongs_to :parent
 
   # You may need to provide a foreign_key like this
-  belongs_to :parent_including_deleted, :class_name => "Parent", foreign_key => 'parent_id', :with_deleted => true
+  belongs_to :parent_including_deleted, :class_name => "Parent", :foreign_key => 'parent_id', :with_deleted => true
 end
 
 parent = Parent.first
@@ -231,5 +255,6 @@ Watch out for these caveats:
 * To [Gonçalo Silva](https://github.com/goncalossilva) for supporting this gem prior to v0.4.3
 * To [Jean Boussier](https://github.com/byroot) for initial Rails 4.0.0 support
 * To [Matijs van Zuijlen](https://github.com/mvz) for Rails 4.1 and 4.2 support
+* To [Andrey Ponomarenko](https://github.com/sjke) for Rails 5 support
 
 See `LICENSE`.

data/lib/acts_as_paranoid.rb

@@ -2,6 +2,7 @@ require 'acts_as_paranoid/core'
 require 'acts_as_paranoid/associations'
 require 'acts_as_paranoid/validations'
 require 'acts_as_paranoid/relation'
+require 'acts_as_paranoid/preloader_association'
 
 module ActsAsParanoid
 
@@ -20,6 +21,7 @@ module ActsAsParanoid
 
     self.paranoid_configuration = { :column => "deleted_at", :column_type => "time", :recover_dependent_associations => true, :dependent_recovery_window => 2.minutes }
     self.paranoid_configuration.merge!({ :deleted_value => "deleted" }) if options[:column_type] == "string"
+    self.paranoid_configuration.merge!({ :allow_nulls => true }) if options[:column_type] == "boolean"
     self.paranoid_configuration.merge!(options) # user options
 
     raise ArgumentError, "'time', 'boolean' or 'string' expected for :column_type option, got #{paranoid_configuration[:column_type]}" unless ['time', 'boolean', 'string'].include? paranoid_configuration[:column_type]
@@ -31,15 +33,15 @@ module ActsAsParanoid
     include ActsAsParanoid::Core
 
     # Magic!
-    default_scope { where(paranoid_default_scope_sql) }
+    default_scope { where(paranoid_default_scope) }
 
     if paranoid_configuration[:column_type] == 'time'
       scope :deleted_inside_time_window, lambda {|time, window|
         deleted_after_time((time - window)).deleted_before_time((time + window))
       }
 
-      scope :deleted_after_time, lambda  { |time| where("#{paranoid_column} > ?", time) }
-      scope :deleted_before_time, lambda { |time| where("#{paranoid_column} < ?", time) }
+      scope :deleted_after_time, lambda  { |time| where("#{self.table_name}.#{paranoid_column} > ?", time) }
+      scope :deleted_before_time, lambda { |time| where("#{self.table_name}.#{paranoid_column} < ?", time) }
     end
   end
 end
@@ -55,3 +57,6 @@ ActiveRecord::Relation.send :include, ActsAsParanoid::Relation
 
 # Push the recover callback onto the activerecord callback list
 ActiveRecord::Callbacks::CALLBACKS.push(:before_recover, :after_recover)
+
+# Use with_deleted in preloader build_scope
+ActiveRecord::Associations::Preloader::Association.send :include, ActsAsParanoid::PreloaderAssociation

data/lib/acts_as_paranoid/core.rb

@@ -23,9 +23,11 @@ module ActsAsParanoid
 
       def only_deleted
         if string_type_with_deleted_value?
-          without_paranoid_default_scope.where("#{paranoid_column_reference} IS ?", paranoid_configuration[:deleted_value])
+          without_paranoid_default_scope.where(paranoid_column_reference => paranoid_configuration[:deleted_value])
+        elsif boolean_type_not_nullable?
+          without_paranoid_default_scope.where(paranoid_column_reference => true)
         else
-          without_paranoid_default_scope.where("#{paranoid_column_reference} IS NOT ?", nil)
+          without_paranoid_default_scope.where.not(paranoid_column_reference => nil)
         end
       end
 
@@ -37,13 +39,14 @@ module ActsAsParanoid
         where(conditions).update_all(["#{paranoid_configuration[:column]} = ?", delete_now_value])
       end
 
-      def paranoid_default_scope_sql
+      def paranoid_default_scope
         if string_type_with_deleted_value?
           self.all.table[paranoid_column].eq(nil).
-            or(self.all.table[paranoid_column].not_eq(paranoid_configuration[:deleted_value])).
-            to_sql
+            or(self.all.table[paranoid_column].not_eq(paranoid_configuration[:deleted_value]))
+        elsif boolean_type_not_nullable?
+          self.all.table[paranoid_column].eq(false)
         else
-          self.all.table[paranoid_column].eq(nil).to_sql
+          self.all.table[paranoid_column].eq(nil)
         end
       end
 
@@ -51,6 +54,10 @@ module ActsAsParanoid
         paranoid_column_type == :string && !paranoid_configuration[:deleted_value].nil?
       end
 
+      def boolean_type_not_nullable?
+        paranoid_column_type == :boolean && !paranoid_configuration[:allow_nulls]
+      end
+
       def paranoid_column
         paranoid_configuration[:column].to_sym
       end
@@ -75,12 +82,15 @@ module ActsAsParanoid
 
       def without_paranoid_default_scope
         scope = self.all
-        if scope.where_values.include? paranoid_default_scope_sql
-          # ActiveRecord 4.1
-          scope.where_values.delete(paranoid_default_scope_sql)
+
+        if ActiveRecord::VERSION::MAJOR < 5
+          # ActiveRecord 4.0.*
+          scope = scope.with_default_scope if ActiveRecord::VERSION::MINOR < 1
+          scope.where_values.delete(paranoid_default_scope)
         else
-          scope = scope.with_default_scope
-          scope.where_values.delete(paranoid_default_scope_sql)
+          scope = scope.unscope(where: paranoid_default_scope)
+          # Fix problems with unscope group chain
+          scope = scope.unscoped if scope.to_sql.include? paranoid_default_scope.to_sql
         end
 
         scope
@@ -122,9 +132,7 @@ module ActsAsParanoid
       end
     end
 
-    def destroy
-      destroy!
-    end
+    alias_method :destroy, :destroy!
 
     def recover(options={})
       options = {
@@ -179,8 +187,13 @@ module ActsAsParanoid
     end
 
     def deleted?
-      !(paranoid_value.nil? ||
-        (self.class.string_type_with_deleted_value? && paranoid_value != self.class.delete_now_value))
+      !if self.class.string_type_with_deleted_value?
+        paranoid_value != self.class.delete_now_value || paranoid_value.nil?
+      elsif self.class.boolean_type_not_nullable?
+        paranoid_value == false
+      else
+        paranoid_value.nil?
+      end
     end
 
     alias_method :destroyed?, :deleted?

data/lib/acts_as_paranoid/preloader_association.rb

@@ -0,0 +1,15 @@
+module ActsAsParanoid
+  module PreloaderAssociation
+    def self.included(base)
+      base.class_eval do
+        def build_scope_with_deleted
+          scope = build_scope_without_deleted
+          scope = scope.with_deleted if options[:with_deleted] && klass.respond_to?(:with_deleted)
+          scope
+        end
+
+        alias_method_chain :build_scope, :deleted
+      end
+    end
+  end
+end

data/lib/acts_as_paranoid/validations.rb

@@ -6,42 +6,76 @@ module ActsAsParanoid
       base.extend ClassMethods
     end
 
-    class UniquenessWithoutDeletedValidator < 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
+    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.and(table[pk_key.to_sym].not_eq(pk_value))
-        end if record.persisted?
+          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|
-          scope_value = record.send(scope_item)
-          relation = relation.and(table[scope_item].eq(scope_value))
+          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
 
-        # Re-add ActsAsParanoid default scope conditions manually.
-        if finder_class.unscoped.where(finder_class.paranoid_default_scope_sql).where(relation).exists?
-          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          # 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
       end
     end
 
     module ClassMethods
       def validates_uniqueness_of_without_deleted(*attr_names)
-        validates_with UniquenessWithoutDeletedValidator, _merge_attributes(attr_names)
+        validates_with UniquenessWithoutDeletedValidator[ActiveRecord::VERSION::MAJOR], _merge_attributes(attr_names)
       end
     end
   end

data/lib/acts_as_paranoid/version.rb

@@ -1,3 +1,3 @@
 module ActsAsParanoid
-  VERSION = "0.5.0.beta2"
+  VERSION = "0.5.0.rc1"
 end

data/test/test_core.rb

@@ -304,8 +304,8 @@ class ParanoidTest < ParanoidBaseTest
       @paranoid_with_callback.recover
     end
 
-      assert @paranoid_with_callback.called_before_recover
-      assert @paranoid_with_callback.called_after_recover
+    assert @paranoid_with_callback.called_before_recover
+    assert @paranoid_with_callback.called_after_recover
   end
 
   def test_delete_by_multiple_id_is_paranoid
@@ -393,4 +393,44 @@ class ParanoidTest < ParanoidBaseTest
     2.times { ps.destroy }
     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
+  end
+
+  def test_boolean_type_with_no_nil_value_after_destroy
+    ps = ParanoidBooleanNotNullable.create!()
+    ps.destroy
+    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
+  end
+
+  def test_boolean_type_with_no_nil_value_after_destroy_with_deleted
+    ps = ParanoidBooleanNotNullable.create!()
+    ps.destroy
+    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
+  end
+
+  def test_boolean_type_with_no_nil_value_after_destroy_only_deleted
+    ps = ParanoidBooleanNotNullable.create!()
+    ps.destroy
+    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!()
+    2.times { ps.destroy }
+    assert_equal 0, ParanoidBooleanNotNullable.with_deleted.where(:id => ps).count
+  end
 end

data/test/test_helper.rb

@@ -111,14 +111,14 @@ def setup_db
 
     create_table :super_paranoids do |t|
       t.string :type
-      t.references :has_many_inherited_super_paranoidz
+      t.references :has_many_inherited_super_paranoidz, index: { name: 'index__sp_id_on_has_many_isp' }
       t.datetime :deleted_at
 
       timestamps t
     end
 
     create_table :has_many_inherited_super_paranoidzs do |t|
-      t.references :super_paranoidz
+      t.references :super_paranoidz, index: { name: 'index_has_many_isp_on_sp_id' }
       t.datetime :deleted_at
 
       timestamps t
@@ -181,6 +181,33 @@ def setup_db
       t.string    :paranoid_thing_type
       t.datetime :deleted_at
     end
+
+    create_table :paranoid_boolean_not_nullables do |t|
+      t.string :name
+      t.boolean :deleted, :boolean, :null => false, :default => false
+    end
+
+    create_table :paranoid_belongs_to_polymorphics do |t|
+      t.string :name
+      t.string :parent_type
+      t.integer :parent_id
+      t.datetime :deleted_at
+
+      t.timestamps
+    end
+
+    create_table :not_paranoid_has_many_as_parents do |t|
+      t.string :name
+
+      t.timestamps
+    end
+
+    create_table :paranoid_has_many_as_parents do |t|
+      t.string :name
+      t.datetime :deleted_at
+
+      t.timestamps
+    end
   end
 end
 
@@ -190,9 +217,12 @@ def timestamps(table)
 end
 
 def teardown_db
-  ActiveRecord::Base.connection.tables.each do |table|
-    ActiveRecord::Base.connection.drop_table(table)
+  tables = if ActiveRecord::VERSION::MAJOR < 5
+    ActiveRecord::Base.connection.tables
+  else
+    ActiveRecord::Base.connection.data_sources
   end
+  tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
 end
 
 class ParanoidTime < ActiveRecord::Base
@@ -351,6 +381,20 @@ class ParanoidWithScopedValidation < ActiveRecord::Base
   validates_uniqueness_of :name, :scope => :category
 end
 
+class ParanoidBelongsToPolymorphic < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :parent, :polymorphic => true, :with_deleted => true
+end
+
+class NotParanoidHasManyAsParent < ActiveRecord::Base
+  has_many :paranoid_belongs_to_polymorphics, :as => :parent, :dependent => :destroy
+end
+
+class ParanoidHasManyAsParent < ActiveRecord::Base
+  acts_as_paranoid
+  has_many :paranoid_belongs_to_polymorphics, :as => :parent, :dependent => :destroy
+end
+
 class ParanoidBaseTest < ActiveSupport::TestCase
   def setup
     setup_db
@@ -421,3 +465,8 @@ class ParanoidSection < ActiveRecord::Base
   belongs_to :paranoid_time
   belongs_to :paranoid_thing, :polymorphic => true, :dependent => :destroy
 end
+
+class ParanoidBooleanNotNullable < ActiveRecord::Base
+  acts_as_paranoid column: 'deleted', column_type: 'boolean', allow_nulls: false
+end
+

data/test/test_preloader_association.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class PreloaderAssociationTest < ParanoidBaseTest
+  def test_includes_with_deleted
+    paranoid_time = ParanoidTime.first
+    paranoid_has_many_dependant = 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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_paranoid
 version: !ruby/object:Gem::Version
-  version: 0.5.0.beta2
+  version: 0.5.0.rc1
 platform: ruby
 authors:
 - Zachary Scott
@@ -10,36 +10,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-17 00:00:00.000000000 Z
+date: 2016-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +126,7 @@ files:
 - lib/acts_as_paranoid.rb
 - lib/acts_as_paranoid/associations.rb
 - lib/acts_as_paranoid/core.rb
+- lib/acts_as_paranoid/preloader_association.rb
 - lib/acts_as_paranoid/relation.rb
 - lib/acts_as_paranoid/validations.rb
 - lib/acts_as_paranoid/version.rb
@@ -122,6 +135,7 @@ files:
 - test/test_default_scopes.rb
 - test/test_helper.rb
 - test/test_inheritance.rb
+- test/test_preloader_association.rb
 - test/test_relations.rb
 - test/test_validations.rb
 homepage: https://github.com/ActsAsParanoid/acts_as_paranoid
@@ -144,16 +158,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Active Record plugin which allows you to hide and restore records without
   actually deleting them.
 test_files:
-- test/test_associations.rb
-- test/test_core.rb
-- test/test_default_scopes.rb
-- test/test_helper.rb
 - test/test_inheritance.rb
+- test/test_preloader_association.rb
 - test/test_relations.rb
+- test/test_core.rb
 - test/test_validations.rb
+- test/test_associations.rb
+- test/test_helper.rb
+- test/test_default_scopes.rb
+has_rdoc: