acts_as_paranoid 0.4.1 → 0.4.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 57c69c6d7676bda21b0f8da016bd556f77003894
+  data.tar.gz: 5293e8a3b417fecdfe117aefddcd8e2a0d2f4b09
+SHA512:
+  metadata.gz: 8ae49e59c2f487c80243bb42c4d6e33c4f1676ecd0d039ba420c1e1e49e02b83a4c6635515d1ef53dd4ba0c68ebce427b386ce684992d4139ef2e4c638f61dd5
+  data.tar.gz: f449a10feae541515688ed6c55446aa815025982f293a2375c44ec74b68a8cfe7928abc1dffee3758a868bca4d6d92eb13632642bb0dc40279d47e5973a7bfb0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Gonçalo Silva
+Copyright (c) 2014 Zachary Scott, Gonçalo Silva, Rick Olson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.markdown → README.md}

@@ -1,15 +1,11 @@
 # ActsAsParanoid
 
+[![Build Status](https://travis-ci.org/ActsAsParanoid/acts_as_paranoid.png?branch=0-4-stable)](https://travis-ci.org/ActsAsParanoid/acts_as_paranoid)
+
 A simple plugin which hides records instead of deleting them, being able to recover them.
 
 **This branch targets Rails 3.2.** If you're working with another version, switch to the corresponding branch.
 
-## Credits
-
-This plugin was inspired by [acts_as_paranoid](http://github.com/technoweenie/acts_as_paranoid) and [acts_as_active](http://github.com/fernandoluizao/acts_as_active).
-
-While porting it to Rails 3, I decided to apply the ideas behind those plugins to an unified solution while removing a **lot** of the complexity found in them. I eventually ended up writing a new plugin from scratch.
-
 ## Usage
 
 You can enable ActsAsParanoid like this:
@@ -186,29 +182,34 @@ Paranoiac.pretty.only_deleted.count #=> 1
 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 ParanoiacParent < ActiveRecord::Base
-	has_many :children, :class_name => "ParanoiacChild"
+class Parent < ActiveRecord::Base
+  has_many :children, :class_name => "ParanoiacChild"
 end
 
 class ParanoiacChild < ActiveRecord::Base
-	belongs_to :parent, :class_name => "ParanoiacParent"
-	belongs_to :parent_with_deleted, :class_name => "ParanoiacParent", :with_deleted => true
+  acts_as_paranoid
+  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
 end
 
-parent = ParanoiacParent.first
+parent = Parent.first
 child = parent.children.create
 parent.destroy
 
 child.parent #=> nil
-child.parent_with_deleted #=> ParanoiacParent (it works!)
+child.parent_including_deleted #=> Parent (it works!)
 ```
 
 ## Caveats
 
 Watch out for these caveats:
 
+
 -   You cannot use scopes named `with_deleted` and `only_deleted`
 -   You cannot use scopes named `deleted_inside_time_window`, `deleted_before_time`, `deleted_after_time` **if** your paranoid column's type is `time`
+-   You cannot name association `*_with_deleted`
 -   `unscoped` will return all records, deleted or not
 
 # Support
@@ -219,20 +220,21 @@ This gem supports the most recent versions of Rails and Ruby.
 
 For Rails 3.2 check the README at the [rails3.2](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.2) branch and add this to your Gemfile:
 
-	gem "acts_as_paranoid", "~>0.4.0"
+    gem "acts_as_paranoid", "~> 0.4.0"
 
 For Rails 3.1 check the README at the [rails3.1](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.1) branch and add this to your Gemfile:
 
-	gem "rails3_acts_as_paranoid", "~>0.1.4"
+    gem "rails3_acts_as_paranoid", "~>0.1.4"
 
 For Rails 3.0 check the README at the [rails3.0](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.0) branch and add this to your Gemfile:
 
-	gem "rails3_acts_as_paranoid", "~>0.0.9"
+    gem "rails3_acts_as_paranoid", "~>0.0.9"
 
 
 ## Ruby
 
-This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode). It *might* work fine in 1.8, but it's not officially supported.
+This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode).
+
 
 # Acknowledgements
 
@@ -244,4 +246,11 @@ This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode). It *might
 * To [Craig Walker](https://github.com/softcraft-development) for Rails 3.1 support and fixing various pending issues
 * To [Charles G.](https://github.com/chuckg) for Rails 3.2 support and for making a desperately needed global code refactoring
 
-Copyright © 2010 Gonçalo Silva, released under the MIT license
+## Credits
+
+This plugin was inspired by [acts_as_paranoid](http://github.com/technoweenie/acts_as_paranoid) and [acts_as_active](http://github.com/fernandoluizao/acts_as_active).
+
+While porting it to Rails 3, I decided to apply the ideas behind those plugins to an unified solution while removing a **lot** of the complexity found in them. I eventually ended up writing a new plugin from scratch.
+
+
+Copyright © 2014 Zachary Scott, Gonçalo Silva, Rick Olson, released under the MIT license

data/lib/acts_as_paranoid/core.rb

@@ -94,7 +94,7 @@ module ActsAsParanoid
         run_callbacks :destroy do
           destroy_dependent_associations!
           # Handle composite keys, otherwise we would just use `self.class.primary_key.to_sym => self.id`.
-          self.class.delete_all!(Hash[[Array(self.class.primary_key), Array(self.id)].transpose])
+          self.class.delete_all!(Hash[[Array(self.class.primary_key), Array(self.id)].transpose]) if persisted?
           self.paranoid_value = self.class.delete_now_value
           freeze
         end
@@ -106,7 +106,7 @@ module ActsAsParanoid
         with_transaction_returning_status do
           run_callbacks :destroy do
             # Handle composite keys, otherwise we would just use `self.class.primary_key.to_sym => self.id`.
-            self.class.delete_all(Hash[[Array(self.class.primary_key), Array(self.id)].transpose])
+            self.class.delete_all(Hash[[Array(self.class.primary_key), Array(self.id)].transpose]) if persisted?
             self.paranoid_value = self.class.delete_now_value
             self
           end
@@ -134,17 +134,17 @@ module ActsAsParanoid
 
     def recover_dependent_associations(window, options)
       self.class.dependent_associations.each do |reflection|
-        next unless reflection.klass.paranoid?
+        next unless (klass = get_reflection_class(reflection)).paranoid?
 
-        scope = reflection.klass.only_deleted
+        scope = klass.only_deleted
 
         # Merge in the association's scope
         scope = scope.merge(association(reflection.name).association_scope)
 
         # We can only recover by window if both parent and dependant have a
         # paranoid column type of :time.
-        if self.class.paranoid_column_type == :time && reflection.klass.paranoid_column_type == :time
-          scope = scope.merge(reflection.klass.deleted_inside_time_window(paranoid_value, window))
+        if self.class.paranoid_column_type == :time && klass.paranoid_column_type == :time
+          scope = scope.merge(klass.deleted_inside_time_window(paranoid_value, window))
         end
 
         scope.each do |object|
@@ -155,9 +155,9 @@ module ActsAsParanoid
 
     def destroy_dependent_associations!
       self.class.dependent_associations.each do |reflection|
-        next unless reflection.klass.paranoid?
+        next unless (klass = get_reflection_class(reflection)).paranoid?
 
-        scope = reflection.klass.only_deleted
+        scope = klass.only_deleted
 
         # Merge in the association's scope
         scope = scope.merge(association(reflection.name).association_scope)
@@ -177,6 +177,14 @@ module ActsAsParanoid
 
     private
 
+    def get_reflection_class(reflection)
+      if reflection.macro == :belongs_to && reflection.options.include?(:polymorphic)
+        self.send(reflection.foreign_type).constantize
+      else
+        reflection.klass
+      end
+    end
+
     def paranoid_value=(value)
       self.send("#{self.class.paranoid_column}=", value)
     end

data/lib/acts_as_paranoid/relation.rb

@@ -5,7 +5,7 @@ module ActsAsParanoid
         def paranoid?
           klass.try(:paranoid?) ? true : false
         end
-        
+
         def paranoid_deletion_attributes
           { klass.paranoid_column => klass.delete_now_value }
         end
@@ -18,7 +18,7 @@ module ActsAsParanoid
             orig_delete_all
           end
         end
-        
+
         def delete_all(conditions = nil)
           if paranoid?
             update_all(paranoid_deletion_attributes, conditions)

data/lib/acts_as_paranoid/version.rb

@@ -0,0 +1,3 @@
+module ActsAsParanoid
+  VERSION = "0.4.5"
+end

data/lib/acts_as_paranoid.rb

@@ -1,27 +1,23 @@
-require 'active_record/base'
-require 'active_record/relation'
-require 'active_record/callbacks'
 require 'acts_as_paranoid/core'
 require 'acts_as_paranoid/associations'
 require 'acts_as_paranoid/validations'
 require 'acts_as_paranoid/relation'
 
-
 module ActsAsParanoid
-  
+
   def paranoid?
     self.included_modules.include?(ActsAsParanoid::Core)
   end
-  
+
   def validates_as_paranoid
     include ActsAsParanoid::Validations
   end
-  
+
   def acts_as_paranoid(options = {})
     raise ArgumentError, "Hash expected, got #{options.class.name}" if not options.is_a?(Hash) and not options.empty?
-    
+
     class_attribute :paranoid_configuration, :paranoid_column_reference
-    
+
     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!(options) # user options
@@ -29,11 +25,11 @@ module ActsAsParanoid
     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]
 
     self.paranoid_column_reference = "#{self.table_name}.#{paranoid_configuration[:column]}"
-    
+
     return if paranoid?
-    
+
     include ActsAsParanoid::Core
-    
+
     # Magic!
     default_scope { where(paranoid_default_scope_sql) }
 
@@ -42,8 +38,8 @@ module ActsAsParanoid
         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

data/test/test_associations.rb

@@ -0,0 +1,222 @@
+require 'test_helper'
+
+class AssociationsTest < ParanoidBaseTest
+  def test_removal_with_associations
+    # This test shows that the current implementation doesn't handle
+    # assciation deletion correctly (when hard deleting via parent-object)
+    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"
+
+    assert_equal 1, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidDeleteCompany.count
+    assert_equal 2, ParanoidProduct.count
+
+    ParanoidDestroyCompany.first.destroy
+    assert_equal 0, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidProduct.count
+    assert_equal 1, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 2, ParanoidProduct.with_deleted.count
+
+    ParanoidDestroyCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDestroyCompany.count
+    assert_equal 1, ParanoidProduct.count
+    assert_equal 0, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 1, ParanoidProduct.with_deleted.count
+
+    ParanoidDeleteCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDeleteCompany.count
+    assert_equal 0, ParanoidProduct.count
+    assert_equal 0, ParanoidDeleteCompany.with_deleted.count
+    assert_equal 0, ParanoidProduct.with_deleted.count
+  end
+
+  def test_belongs_to_with_deleted
+    paranoid_time = ParanoidTime.first
+    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
+
+    assert_nil paranoid_has_many_dependant.paranoid_time(true)
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time_with_deleted(true)
+  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)
+
+    assert_equal paranoid_time, paranoid_has_many_dependant.paranoid_time
+    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)
+  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)
+
+    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)
+  end
+
+  def test_belongs_to_options
+    paranoid_time = ParanoidHasManyDependant.reflections[: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[: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[: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
+
+  def test_only_find_associated_records_when_finding_with_paranoid_deleted
+    parent = ParanoidBelongsDependant.create
+    child = ParanoidHasManyDependant.create
+    parent.paranoid_has_many_dependants << child
+
+    unrelated_parent = ParanoidBelongsDependant.create
+    unrelated_child = ParanoidHasManyDependant.create
+    unrelated_parent.paranoid_has_many_dependants << unrelated_child
+
+    child.destroy
+    assert_paranoid_deletion(child)
+
+    assert_equal [child], parent.paranoid_has_many_dependants.with_deleted.to_a
+  end
+
+  def test_cannot_find_a_paranoid_deleted_many_many_association
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    left.paranoid_many_many_parent_rights.delete(right)
+
+    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"
+  end
+
+  def test_cannot_find_a_paranoid_destroyed_many_many_association
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    left.paranoid_many_many_parent_rights.destroy(right)
+
+    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"
+  end
+
+  def test_cannot_find_a_has_many_through_object_when_its_linking_object_is_paranoid_destroyed
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    left.paranoid_many_many_parent_rights << right
+
+    child = left.paranoid_many_many_children.first
+
+    child.destroy
+
+    left.reload
+
+    assert_equal [], left.paranoid_many_many_parent_rights, "Associated objects not deleted"
+  end
+
+  def test_cannot_find_a_paranoid_deleted_model
+    model = ParanoidBelongsDependant.create
+    model.destroy
+
+    assert_raises ActiveRecord::RecordNotFound do
+      ParanoidBelongsDependant.find(model.id)
+    end
+  end
+
+  def test_bidirectional_has_many_through_association_clear_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    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"
+
+    left.paranoid_many_many_parent_rights.clear
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_bidirectional_has_many_through_association_destroy_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    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"
+
+    left.paranoid_many_many_parent_rights.destroy(right)
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_bidirectional_has_many_through_association_delete_is_paranoid
+    left = ParanoidManyManyParentLeft.create
+    right = ParanoidManyManyParentRight.create
+    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"
+
+    left.paranoid_many_many_parent_rights.delete(right)
+
+    assert_paranoid_deletion(child)
+  end
+
+  def test_belongs_to_on_normal_model_is_paranoid
+    not_paranoid = HasOneNotParanoid.create
+    not_paranoid.paranoid_time = ParanoidTime.create
+
+    assert not_paranoid.save
+    assert_not_nil not_paranoid.paranoid_time
+  end
+
+  def test_double_belongs_to_with_deleted
+    not_paranoid = DoubleHasOneNotParanoid.create
+    not_paranoid.paranoid_time = ParanoidTime.create
+
+    assert not_paranoid.save
+    assert_not_nil not_paranoid.paranoid_time
+  end
+
+  def test_mass_assignment_of_paranoid_column_enabled
+    now = Time.now
+    record = ParanoidTime.create! :name => 'Foo', :deleted_at => now
+    assert_equal 'Foo', record.name
+    assert_equal now, record.deleted_at
+  end
+end