Merge branch 'rails4' into setting_restore

.travis.yml

@@ -7,5 +7,5 @@ rvm:
   - rbx
 
 env:
-  - RAILS='~> 4.0.2'
-  - RAILS='~> 4.1.0.beta1'
+  - RAILS='~> 4.0.4'
+  - RAILS='~> 4.1.0'

README.md

@@ -2,37 +2,37 @@
 
 Paranoia is a re-implementation of [acts\_as\_paranoid](http://github.com/technoweenie/acts_as_paranoid) for Rails 3, using much, much, much less code.
 
-You would use either plugin / gem if you wished that when you called `destroy` on an Active Record object that it didn't actually destroy it, but just "hid" the record. Paranoia does this by setting a `deleted_at` field to the current time when you `destroy` a record, and hides it by scoping all queries on your model to only include records which do not have a `deleted_at` field.
+You would use either plugin / gem if you wished that when you called `destroy` on an Active Record object that it didn't actually destroy it, but just *hide* the record. Paranoia does this by setting a `deleted_at` field to the current time when you `destroy` a record, and hides it by scoping all queries on your model to only include records which do not have a `deleted_at` field.
 
-If you wish to actually destroy an object you may call `really_destroy!`.
+If you wish to actually destroy an object you may call `really_destroy!`. **WARNING**: This will also *really destroy* all `dependent: destroy` records, so please aim this method away from face when using.**
 
-If a record has `has_many` associations defined AND those associations have `dependent: :destroy` set on them, then they will also be soft-deleted if ``acts_as_paranoid`` is set,  otherwise the normal destroy will be called. 
+If a record has `has_many` associations defined AND those associations have `dependent: :destroy` set on them, then they will also be soft-deleted if `acts_as_paranoid` is set,  otherwise the normal destroy will be called. 
 
 ## Installation & Usage
 
 For Rails 3, please use version 1 of Paranoia:
 
-```ruby
-gem 'paranoia', '~> 1.0'
+``` ruby
+gem "paranoia", "~> 1.0"
 ```
 
 For Rails 4, please use version 2 of Paranoia:
 
-```ruby
-gem 'paranoia', '~> 2.0'
+``` ruby
+gem "paranoia", "~> 2.0"
 ```
 
 Of course you can install this from GitHub as well:
 
-```ruby
-gem 'paranoia', :github => 'radar/paranoia', :branch => 'master'
+``` ruby
+gem "paranoia", :github => "radar/paranoia", :branch => "master"
 # or
-gem 'paranoia', :github => 'radar/paranoia', :branch => 'rails4'
+gem "paranoia", :github => "radar/paranoia", :branch => "rails4"
 ```
 
 Then run:
 
-```shell
+``` shell
 bundle install
 ```
 
@@ -42,13 +42,13 @@ Updating is as simple as `bundle update paranoia`.
 
 Run:
 
-```shell
+``` shell
 rails generate migration AddDeletedAtToClients deleted_at:datetime:index
 ```
 
 and now you have a migration
 
-```ruby
+``` ruby
 class AddDeletedAtToClients < ActiveRecord::Migration
   def change
     add_column :clients, :deleted_at, :datetime
@@ -61,33 +61,38 @@ end
 
 #### In your model:
 
-```ruby
+``` ruby
 class Client < ActiveRecord::Base
   acts_as_paranoid
 
-  ...
+  # ...
 end
 ```
 
 Hey presto, it's there! Calling `destroy` will now set the `deleted_at` column:
 
 
-```
->> client.deleted_at => nil
->> client.destroy => client
->> client.deleted_at => [current timestamp]
+``` ruby
+>> client.deleted_at
+# => nil
+>> client.destroy 
+# => client
+>> client.deleted_at 
+# => [current timestamp]
 ```
 
-If you really want it gone *gone*, call `really_destroy!`
+If you really want it gone *gone*, call `really_destroy!`:
 
-```
->> client.deleted_at => nil
->> client.really_destroy! => client
+``` ruby
+>> client.deleted_at
+# => nil
+>> client.really_destroy!
+# => client
 ```
 
 If you want a method to be called on destroy, simply provide a `before_destroy` callback:
 
-```ruby
+``` ruby
 class Client < ActiveRecord::Base
   acts_as_paranoid
 
@@ -97,13 +102,13 @@ class Client < ActiveRecord::Base
     # do stuff
   end
 
-  ...
+  # ...
 end
 ```
 
 If you want to use a column other than `deleted_at`, you can pass it as an option:
 
-```ruby
+``` ruby
 class Client < ActiveRecord::Base
   acts_as_paranoid column: :destroyed_at
 
@@ -113,7 +118,7 @@ end
 
 If you want to access soft-deleted associations, override the getter method:
 
-```ruby
+``` ruby
 def product
   Product.unscoped { super }
 end
@@ -121,43 +126,43 @@ end
 
 If you want to find all records, even those which are deleted:
 
-```ruby
+``` ruby
 Client.with_deleted
 ```
 
 If you want to find only the deleted records:
 
-```ruby
+``` ruby
 Client.only_deleted
 ```
 
 If you want to check if a record is soft-deleted:
 
-```ruby
+``` ruby
 client.destroyed?
 ```
 
 If you want to restore a record:
 
-```ruby
+``` ruby
 Client.restore(id)
 ```
 
 If you want to restore a whole bunch of records:
 
-```ruby
+``` ruby
 Client.restore([id1, id2, ..., idN])
 ```
 
 If you want to restore a record and their dependently destroyed associated records:
 
-```ruby
+``` ruby
 Client.restore(id, :recursive => true)
 ```
 
 If you want callbacks to trigger before a restore:
 
-```ruby
+``` ruby
 before_restore :callback_name_goes_here
 ```
 
@@ -165,7 +170,7 @@ For more information, please look at the tests.
 
 ## Acts As Paranoid Migration
 
-You can replace the older acts_as_paranoid methods as follows:
+You can replace the older `acts_as_paranoid` methods as follows:
 
 | Old Syntax                 | New Syntax                     |
 |:-------------------------- |:------------------------------ |

lib/paranoia.rb

+require 'active_record' unless defined? ActiveRecord
+
 module Paranoia
   def self.included(klazz)
     klazz.extend Query
@@ -88,12 +90,17 @@ module Paranoia
   # insert time to paranoia column.
   # @param with_transaction [Boolean] exec with ActiveRecord Transactions.
   def touch_paranoia_column(with_transaction=false)
+    # This method is (potentially) called from really_destroy
+    # The object the method is being called on may be frozen
+    # Let's not touch it if it's frozen.
+    unless self.frozen?
       if with_transaction
         with_transaction_returning_status { touch(paranoia_column) }
       else
         touch(paranoia_column)
       end
     end
+  end
 
   # restore associated records that have been soft deleted when
   # we called #destroy
@@ -124,9 +131,23 @@ end
 
 class ActiveRecord::Base
   def self.acts_as_paranoid(options={})
-    alias :really_destroy! :destroy
     alias :destroy! :destroy
     alias :delete! :delete
+    def really_destroy!
+      dependent_reflections = self.reflections.select do |name, reflection|
+        reflection.options[:dependent] == :destroy
+      end
+      if dependent_reflections.any?
+        dependent_reflections.each do |name, _|
+          associated_records = self.send(name)
+          # Paranoid models will have this method, non-paranoid models will not
+          associated_records = associated_records.with_deleted if associated_records.respond_to?(:with_deleted)
+          associated_records.each(&:really_destroy!)
+        end
+      end
+      destroy!
+    end
+
     include Paranoia
     class_attribute :paranoia_column
 
@@ -168,3 +189,5 @@ class ActiveRecord::Base
     self.class.paranoia_column
   end
 end
+
+require 'paranoia/rspec' if defined? RSpec

lib/paranoia/rspec.rb

+require 'rspec/expectations'
+
+# Validate the subject's class did call "acts_as_paranoid"
+RSpec::Matchers.define :act_as_paranoid do
+  match { |subject| subject.class.ancestors.include?(Paranoia) }
+
+  failure_message_for_should { "#{subject.class} should use `acts_as_paranoid`" }
+  failure_message_for_should_not { "#{subject.class} should not use `acts_as_paranoid`" }
+end

test/paranoia_test.rb

@@ -287,13 +287,39 @@ class ParanoiaTest < test_framework
     assert model.instance_variable_get(:@restore_callback_called)
   end
 
-  def test_real_destroy
+  def test_really_destroy
     model = ParanoidModel.new
     model.save
     model.really_destroy!
     refute ParanoidModel.unscoped.exists?(model.id)
   end
 
+  def test_real_destroy_dependent_destroy
+    parent = ParentModel.create
+    child = parent.very_related_models.create
+    parent.really_destroy!
+    refute RelatedModel.unscoped.exists?(child.id)
+  end
+
+  def test_real_destroy_dependent_destroy_after_normal_destroy
+    parent = ParentModel.create
+    child = parent.very_related_models.create
+    parent.destroy
+    parent.really_destroy!
+    refute RelatedModel.unscoped.exists?(child.id)
+  end
+
+  def test_real_destroy_dependent_destroy_after_normal_destroy_does_not_delete_other_children
+    parent_1 = ParentModel.create
+    child_1 = parent_1.very_related_models.create
+
+    parent_2 = ParentModel.create
+    child_2 = parent_2.very_related_models.create
+    parent_1.destroy
+    parent_1.really_destroy!
+    assert RelatedModel.unscoped.exists?(child_2.id)
+  end
+
   if ActiveRecord::VERSION::STRING < "4.1"
     def test_real_destroy
       model = ParanoidModel.new