paranoia 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fe3ef85f4b72d9f860b21f59bcf8f0416b6462f
-  data.tar.gz: a60d2f35334726d1d2af0fc45c03fe0a8fbe8653
+  metadata.gz: 691a38d6362b87d499cca9ca12d0988c45acbdcd
+  data.tar.gz: 8bbbab8f2754a65876552d494c93373186f89a04
 SHA512:
-  metadata.gz: d9c966fc4c04b1ce8bc50bdaf988f7d16290cece9913dcd49cfe738d8751f692450f4daf57e7fe0289c6575dad031317756462326232efb5418a03d427560642
-  data.tar.gz: 76b091060495418ac3ccf2163a226b8ce43f6ec2e078e75a55e16c566bd968715a9a2694f3b4358e51e308a2be17f674ab9f50fc205c2e75e7e2d04b23ddef59
+  metadata.gz: 5bb99eaac69f702473907da7b3988ed9487b4bd8904817dcf6e670498692343414c7db9f4fb987157953fb8cefcccd91a9ddae1d13186ddcb0d4f366b2448818
+  data.tar.gz: d363de9761f82f26fcc927892b6cbe4f9ee60f9a41ad1ae878f7586d73f65a6c69263ffa1028e22b660aa9063823b33d867b4a090e4308267cb00bb80864e073

data/.travis.yml

@@ -4,8 +4,7 @@ rvm:
   - 2.0.0
   - 2.1.0
   - jruby-19mode
-  - rbx
 
 env:
-  - RAILS='~> 4.0.2'
-  - RAILS='~> 4.1.0.beta1'
+  - RAILS='~> 4.0.8'
+  - RAILS='~> 4.1.4'

data/Gemfile

@@ -9,7 +9,7 @@ platforms :rbx do
   gem 'rubinius-developer_tools'
 end
 
-rails = ENV['RAILS'] || '~> 4.0.2'
+rails = ENV['RAILS'] || '~> 4.1.4'
 
 gem 'rails', rails
 

data/README.md

@@ -1,36 +1,38 @@
 # Paranoia
 
-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.
+Paranoia is a re-implementation of [acts\_as\_paranoid](http://github.com/technoweenie/acts_as_paranoid) for Rails 3 and Rails 4, 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.
 
 ## 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
 ```
 
@@ -40,16 +42,17 @@ Updating is as simple as `bundle update paranoia`.
 
 Run:
 
-```shell
-rails generate migration AddDeletedAtToClients deleted_at:datetime
+``` 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
+    add_index :clients, :deleted_at
   end
 end
 ```
@@ -58,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.real_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
 
@@ -94,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
 
@@ -110,7 +118,7 @@ end
 
 If you want to access soft-deleted associations, override the getter method:
 
-```ruby
+``` ruby
 def product
   Product.unscoped { super }
 end
@@ -118,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
 ```
 
@@ -162,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                     |
 |:-------------------------- |:------------------------------ |
@@ -170,6 +178,31 @@ You can replace the older acts_as_paranoid methods as follows:
 |`find_with_deleted(:first)` | `Client.with_deleted.first`    |
 |`find_with_deleted(id)`     | `Client.with_deleted.find(id)` |
 
+
+The `recover` method in `acts_as_paranoid` runs `update` callbacks.  Paranoia's
+`restore` method does not do this.
+
+## Support for Unique Keys with Null Values
+
+Most databases ignore null columns when it comes to resolving unique index
+constraints.  This means unique constraints that involve nullable columns may be
+problematic. Instead of using `NULL` to represent a not-deleted row, you can pick
+a value that you want paranoia to mean not deleted. Note that you can/should
+now apply a `NOT NULL` constraint to your `deleted_at` column.
+
+Per model:
+
+```ruby
+# pick some value
+acts_as_paranoid sentinel_value: DateTime.new(0)
+```
+
+or globally in a rails initializer, e.g. `config/initializer/paranoia.rb`
+
+```ruby
+Paranoia.default_sentinel_value = DateTime.new(0)
+```
+
 ## License
 
 This gem is released under the MIT license.

data/lib/paranoia.rb

@@ -1,4 +1,17 @@
+require 'active_record' unless defined? ActiveRecord
+
 module Paranoia
+  @@default_sentinel_value = nil
+
+  # Change default_sentinel_value in a rails initilizer
+  def self.default_sentinel_value=(val)
+    @@default_sentinel_value = val
+  end
+
+  def self.default_sentinel_value
+    @@default_sentinel_value
+  end
+
   def self.included(klazz)
     klazz.extend Query
     klazz.extend Callbacks
@@ -16,16 +29,12 @@ module Paranoia
     end
 
     def only_deleted
-      with_deleted.where.not(paranoia_column => nil)
+      with_deleted.where.not(table_name => { paranoia_column => paranoia_sentinel_value} )
     end
     alias :deleted :only_deleted
 
     def restore(id, opts = {})
-      if id.is_a?(Array)
-        id.map { |one_id| restore(one_id, opts) }
-      else
-        only_deleted.find(id).restore!(opts)
-      end
+      Array(id).flatten.map { |one_id| only_deleted.find(one_id).restore!(opts) }
     end
   end
 
@@ -48,7 +57,12 @@ module Paranoia
   end
 
   def destroy
-    run_callbacks(:destroy) { touch_paranoia_column(true) }
+    callbacks_result = transaction do
+      run_callbacks(:destroy) do
+        touch_paranoia_column
+      end
+    end
+    callbacks_result ? self : false
   end
 
   # As of Rails 4.1.0 +destroy!+ will no longer remove the record from the db
@@ -67,17 +81,25 @@ module Paranoia
   end
 
   def restore!(opts = {})
-    ActiveRecord::Base.transaction do
+    self.class.transaction do
       run_callbacks(:restore) do
-        update_column paranoia_column, nil
+        # Fixes a bug where the build would error because attributes were frozen.
+        # This only happened on Rails versions earlier than 4.1.
+        noop_if_frozen = ActiveRecord.version < Gem::Version.new("4.1")
+        if (noop_if_frozen && !@attributes.frozen?) || !noop_if_frozen
+          write_attribute paranoia_column, paranoia_sentinel_value
+          update_column paranoia_column, paranoia_sentinel_value
+        end
         restore_associated_records if opts[:recursive]
       end
     end
+
+    self
   end
   alias :restore :restore!
 
   def destroyed?
-    !!send(paranoia_column)
+    send(paranoia_column) != paranoia_sentinel_value
   end
   alias :deleted? :destroyed?
 
@@ -87,10 +109,15 @@ module Paranoia
   # insert time to paranoia column.
   # @param with_transaction [Boolean] exec with ActiveRecord Transactions.
   def touch_paranoia_column(with_transaction=false)
-    if with_transaction
-      with_transaction_returning_status { touch(paranoia_column) }
-    else
-      touch(paranoia_column)
+    # 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
 
@@ -102,25 +129,61 @@ module Paranoia
     end
 
     destroyed_associations.each do |association|
-      association = send(association.name)
+      association_data = send(association.name)
+
+      unless association_data.nil?
+        if association_data.paranoid?
+          if association.collection?
+            association_data.only_deleted.each { |record| record.restore(:recursive => true) }
+          else
+            association_data.restore(:recursive => true)
+          end
+        end
+      end
 
-      if association.paranoid?
-        association.only_deleted.each { |record| record.restore(:recursive => true) }
+      if association_data.nil? && association.macro.to_s == "has_one"
+        association_class_name = association.options[:class_name].present? ? association.options[:class_name] : association.name.to_s.camelize
+        association_foreign_key = association.options[:foreign_key].present? ? association.options[:foreign_key] : "#{self.class.name.to_s.underscore}_id"
+        Object.const_get(association_class_name).only_deleted.where(association_foreign_key, self.id).first.try(:restore, recursive: true)
       end
     end
+
+    clear_association_cache if destroyed_associations.present?
   end
 end
 
 class ActiveRecord::Base
   def self.acts_as_paranoid(options={})
-    alias :really_destroy! :destroy
+    raise "primary key required for "+self.name unless self.primary_key
     alias :destroy! :destroy
     alias :delete! :delete
+    def really_destroy!
+      dependent_reflections = self.class.reflections.select do |name, reflection|
+        reflection.options[:dependent] == :destroy
+      end
+      if dependent_reflections.any?
+        dependent_reflections.each do |name, _|
+          associated_records = self.send(name)
+          # has_one association can return nil
+          if associated_records && associated_records.respond_to?(:with_deleted)
+            # Paranoid models will have this method, non-paranoid models will not
+            associated_records.with_deleted.each(&:really_destroy!)
+            self.send(name).reload
+          elsif associated_records && !associated_records.respond_to?(:each) # single record
+            associated_records.really_destroy!
+          end
+        end
+      end
+      touch_paranoia_column if ActiveRecord::VERSION::STRING >= "4.1"
+      destroy!
+    end
+
     include Paranoia
-    class_attribute :paranoia_column
+    class_attribute :paranoia_column, :paranoia_sentinel_value
 
-    self.paranoia_column = options[:column] || :deleted_at
-    default_scope { where(paranoia_column => nil) }
+    self.paranoia_column = (options[:column] || :deleted_at).to_s
+    self.paranoia_sentinel_value = options.fetch(:sentinel_value) { Paranoia.default_sentinel_value }
+    default_scope { where(table_name => { paranoia_column => paranoia_sentinel_value }) }
 
     before_restore {
       self.class.notify_observers(:before_restore, self) if self.class.respond_to?(:notify_observers)
@@ -156,4 +219,10 @@ class ActiveRecord::Base
   def paranoia_column
     self.class.paranoia_column
   end
+
+  def paranoia_sentinel_value
+    self.class.paranoia_sentinel_value
+  end
 end
+
+require 'paranoia/rspec' if defined? RSpec

data/lib/paranoia/rspec.rb

@@ -0,0 +1,13 @@
+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 { "expected #{subject.class} to use `acts_as_paranoid`" }
+  failure_message_when_negated { "expected #{subject.class} not to use `acts_as_paranoid`" }
+
+  # RSpec 2 compatibility:
+  alias_method :failure_message_for_should, :failure_message
+  alias_method :failure_message_for_should_not, :failure_message_when_negated
+end

data/lib/paranoia/version.rb

@@ -1,3 +1,3 @@
 module Paranoia
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

data/test/paranoia_test.rb

@@ -9,18 +9,35 @@ else
 end
 require File.expand_path(File.dirname(__FILE__) + "/../lib/paranoia")
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', database: ':memory:'
-ActiveRecord::Base.connection.execute 'CREATE TABLE parent_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE featureful_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME, name VARCHAR(32))'
-ActiveRecord::Base.connection.execute 'CREATE TABLE plain_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE callback_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE related_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER NOT NULL, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE employers (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE employees (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE jobs (id INTEGER NOT NULL PRIMARY KEY, employer_id INTEGER NOT NULL, employee_id INTEGER NOT NULL, deleted_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE custom_column_models (id INTEGER NOT NULL PRIMARY KEY, destroyed_at DATETIME)'
-ActiveRecord::Base.connection.execute 'CREATE TABLE non_paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER)'
+def connect!
+  ActiveRecord::Base.establish_connection :adapter => 'sqlite3', database: ':memory:'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE parent_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_model_with_belongs (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME, paranoid_model_with_has_one_id INTEGER)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_model_with_anthor_class_name_belongs (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME, paranoid_model_with_has_one_id INTEGER)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE paranoid_model_with_foreign_key_belongs (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME, has_one_foreign_key_id INTEGER)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE featureful_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME, name VARCHAR(32))'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE plain_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE callback_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE fail_callback_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE related_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER NOT NULL, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE asplode_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE employers (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE employees (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE jobs (id INTEGER NOT NULL PRIMARY KEY, employer_id INTEGER NOT NULL, employee_id INTEGER NOT NULL, deleted_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE custom_column_models (id INTEGER NOT NULL PRIMARY KEY, destroyed_at DATETIME)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE custom_sentinel_models (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME NOT NULL)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE non_paranoid_models (id INTEGER NOT NULL PRIMARY KEY, parent_model_id INTEGER)'
+  ActiveRecord::Base.connection.execute 'CREATE TABLE idless_models (deleted_at DATETIME)'
+end
+
+class WithDifferentConnection < ActiveRecord::Base
+  establish_connection adapter: 'sqlite3', database: ':memory:'
+  connection.execute 'CREATE TABLE with_different_connections (id INTEGER NOT NULL PRIMARY KEY, deleted_at DATETIME)'
+  acts_as_paranoid
+end
+
+connect!
 
 class ParanoiaTest < test_framework
   def setup
@@ -97,7 +114,7 @@ class ParanoiaTest < test_framework
     assert_equal nil, model.instance_variable_get(:@validate_called)
     assert_equal nil, model.instance_variable_get(:@destroy_callback_called)
     assert_equal nil, model.instance_variable_get(:@after_destroy_callback_called)
-    assert_equal nil, model.instance_variable_get(:@after_commit_callback_called)
+    assert model.instance_variable_get(:@after_commit_callback_called)
   end
 
   def test_destroy_behavior_for_paranoid_models
@@ -145,6 +162,36 @@ class ParanoiaTest < test_framework
     assert_equal 1, model.class.deleted.count
   end
 
+  def test_default_sentinel_value
+    assert_equal nil, ParanoidModel.paranoia_sentinel_value
+  end
+
+  def test_sentinel_value_for_custom_sentinel_models
+    model = CustomSentinelModel.new
+    assert_equal 0, model.class.count
+    model.save!
+    assert_equal DateTime.new(0), model.deleted_at
+    assert_equal 1, model.class.count
+    model.destroy
+
+    assert DateTime.new(0) != model.deleted_at
+    assert model.destroyed?
+
+    assert_equal 0, model.class.count
+    assert_equal 1, model.class.unscoped.count
+    assert_equal 1, model.class.only_deleted.count
+    assert_equal 1, model.class.deleted.count
+
+    model.restore
+    assert_equal DateTime.new(0), model.deleted_at
+    assert !model.destroyed?
+
+    assert_equal 1, model.class.count
+    assert_equal 1, model.class.unscoped.count
+    assert_equal 0, model.class.only_deleted.count
+    assert_equal 0, model.class.deleted.count
+  end
+
   def test_destroy_behavior_for_featureful_paranoid_models
     model = get_featureful_model
     assert_equal 0, model.class.count
@@ -246,6 +293,13 @@ class ParanoiaTest < test_framework
     assert_equal false, model.destroyed?
   end
 
+  def test_restore_on_object_return_self
+    model = ParanoidModel.create
+    model.destroy
+
+    assert_equal model.class, model.restore.class
+  end
+
   # Regression test for #92
   def test_destroy_twice
     model = ParanoidModel.new
@@ -256,6 +310,20 @@ class ParanoiaTest < test_framework
     assert_equal 1, ParanoidModel.unscoped.where(id: model.id).count
   end
 
+  def test_destroy_return_value_on_success
+    model = ParanoidModel.create
+    return_value = model.destroy
+
+    assert_equal(return_value, model)
+  end
+
+  def test_destroy_return_value_on_failure
+    model = FailCallbackModel.create
+    return_value = model.destroy
+
+    assert_equal(return_value, false)
+  end
+
   def test_restore_behavior_for_callbacks
     model = CallbackModel.new
     model.save
@@ -271,13 +339,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
@@ -350,6 +444,113 @@ class ParanoiaTest < test_framework
     assert_equal true, second_child.destroyed?
   end
 
+  # regression tests for #118
+  def test_restore_with_has_one_association
+    # setup and destroy test objects
+    hasOne = ParanoidModelWithHasOne.create
+    belongsTo = ParanoidModelWithBelong.create
+    anthorClassName = ParanoidModelWithAnthorClassNameBelong.create
+    foreignKey = ParanoidModelWithForeignKeyBelong.create
+    hasOne.paranoid_model_with_belong = belongsTo
+    hasOne.class_name_belong = anthorClassName
+    hasOne.paranoid_model_with_foreign_key_belong = foreignKey
+    hasOne.save!
+
+    hasOne.destroy
+    assert_equal false, hasOne.deleted_at.nil?
+    assert_equal false, belongsTo.deleted_at.nil?
+
+    # Does it restore has_one associations?
+    hasOne.restore(:recursive => true)
+    hasOne.save!
+
+    assert_equal true, hasOne.reload.deleted_at.nil?
+    assert_equal true, belongsTo.reload.deleted_at.nil?, "#{belongsTo.deleted_at}"
+    assert ParanoidModelWithBelong.with_deleted.reload.count != 0, "There should be a record"
+    assert ParanoidModelWithAnthorClassNameBelong.with_deleted.reload.count != 0, "There should be an other record"
+    assert ParanoidModelWithForeignKeyBelong.with_deleted.reload.count != 0, "There should be a foreign_key record"
+  end
+
+  def test_new_restore_with_has_one_association
+    # setup and destroy test objects
+    hasOne = ParanoidModelWithHasOne.create
+    belongsTo = ParanoidModelWithBelong.create
+    anthorClassName = ParanoidModelWithAnthorClassNameBelong.create
+    foreignKey = ParanoidModelWithForeignKeyBelong.create
+    hasOne.paranoid_model_with_belong = belongsTo
+    hasOne.class_name_belong = anthorClassName
+    hasOne.paranoid_model_with_foreign_key_belong = foreignKey
+    hasOne.save!
+
+    hasOne.destroy
+    assert_equal false, hasOne.deleted_at.nil?
+    assert_equal false, belongsTo.deleted_at.nil?
+
+    # Does it restore has_one associations?
+    newHasOne = ParanoidModelWithHasOne.with_deleted.find(hasOne.id)
+    newHasOne.restore(:recursive => true)
+    newHasOne.save!
+
+    assert_equal true, hasOne.reload.deleted_at.nil?
+    assert_equal true, belongsTo.reload.deleted_at.nil?, "#{belongsTo.deleted_at}"
+    assert ParanoidModelWithBelong.with_deleted.reload.count != 0, "There should be a record"
+    assert ParanoidModelWithAnthorClassNameBelong.with_deleted.reload.count != 0, "There should be an other record"
+    assert ParanoidModelWithForeignKeyBelong.with_deleted.reload.count != 0, "There should be a foreign_key record"
+  end
+
+  def test_model_restore_with_has_one_association
+    # setup and destroy test objects
+    hasOne = ParanoidModelWithHasOne.create
+    belongsTo = ParanoidModelWithBelong.create
+    anthorClassName = ParanoidModelWithAnthorClassNameBelong.create
+    foreignKey = ParanoidModelWithForeignKeyBelong.create
+    hasOne.paranoid_model_with_belong = belongsTo
+    hasOne.class_name_belong = anthorClassName
+    hasOne.paranoid_model_with_foreign_key_belong = foreignKey
+    hasOne.save!
+
+    hasOne.destroy
+    assert_equal false, hasOne.deleted_at.nil?
+    assert_equal false, belongsTo.deleted_at.nil?
+
+    # Does it restore has_one associations?
+    ParanoidModelWithHasOne.restore(hasOne.id, :recursive => true)
+    hasOne.save!
+
+    assert_equal true, hasOne.reload.deleted_at.nil?
+    assert_equal true, belongsTo.reload.deleted_at.nil?, "#{belongsTo.deleted_at}"
+    assert ParanoidModelWithBelong.with_deleted.reload.count != 0, "There should be a record"
+    assert ParanoidModelWithAnthorClassNameBelong.with_deleted.reload.count != 0, "There should be an other record"
+    assert ParanoidModelWithForeignKeyBelong.with_deleted.reload.count != 0, "There should be a foreign_key record"
+  end
+
+  def test_restore_with_nil_has_one_association
+    # setup and destroy test object
+    hasOne = ParanoidModelWithHasOne.create
+    hasOne.destroy
+    assert_equal false, hasOne.reload.deleted_at.nil?
+
+    # Does it raise NoMethodException on restore of nil
+    hasOne.restore(:recursive => true)
+    
+    assert hasOne.reload.deleted_at.nil?
+  end
+  
+  # covers #131
+  def test_has_one_really_destroy_with_nil
+    model = ParanoidModelWithHasOne.create
+    model.really_destroy!
+    
+    refute ParanoidModelWithBelong.unscoped.exists?(model.id)
+  end
+  
+  def test_has_one_really_destroy_with_record
+    model = ParanoidModelWithHasOne.create { |record| record.build_paranoid_model_with_belong }
+    model.really_destroy!
+    
+    refute ParanoidModelWithBelong.unscoped.exists?(model.id)
+  end
+
   def test_observers_notified
     a = ParanoidModelWithObservers.create
     a.destroy
@@ -375,6 +576,57 @@ class ParanoiaTest < test_framework
 }, output
   end
 
+  def test_destroy_fails_if_callback_raises_exception
+    parent = AsplodeModel.create
+
+    assert_raises(StandardError) { parent.destroy }
+
+    #transaction should be rolled back, so parent NOT deleted
+    refute parent.destroyed?, 'Parent record was destroyed, even though AR callback threw exception'
+  end
+
+  def test_destroy_fails_if_association_callback_raises_exception
+    parent = ParentModel.create
+    children = []
+    3.times { children << parent.asplode_models.create }
+
+    assert_raises(StandardError) { parent.destroy }
+
+    #transaction should be rolled back, so parent and children NOT deleted
+    refute parent.destroyed?, 'Parent record was destroyed, even though AR callback threw exception'
+    refute children.any?(&:destroyed?), 'Child record was destroyed, even though AR callback threw exception'
+  end
+
+  def test_restore_model_with_different_connection
+    ActiveRecord::Base.remove_connection # Disconnect the main connection
+    a = WithDifferentConnection.create
+    a.destroy!
+    a.restore!
+    # This test passes if no exception is raised
+    connect! # Reconnect the main connection
+  end
+
+  def test_restore_clear_association_cache_if_associations_present
+    parent = ParentModel.create
+    3.times { parent.very_related_models.create }
+
+    parent.destroy
+
+    assert_equal 0, parent.very_related_models.count
+    assert_equal 0, parent.very_related_models.size
+
+    parent.restore(recursive: true)
+
+    assert_equal 3, parent.very_related_models.count
+    assert_equal 3, parent.very_related_models.size
+  end
+
+  def test_model_without_primary_key
+    assert_raises(RuntimeError) do
+      IdlessModel.class_eval{ acts_as_paranoid }
+    end
+  end
+
   private
   def get_featureful_model
     FeaturefulModel.new(:name => "not empty")
@@ -388,6 +640,13 @@ class ParanoidModel < ActiveRecord::Base
   acts_as_paranoid
 end
 
+class FailCallbackModel < ActiveRecord::Base
+  belongs_to :parent_model
+  acts_as_paranoid
+
+  before_destroy { |_| false }
+end
+
 class FeaturefulModel < ActiveRecord::Base
   acts_as_paranoid
   validates :name, :presence => true, :uniqueness => true
@@ -419,6 +678,7 @@ class ParentModel < ActiveRecord::Base
   has_many :related_models
   has_many :very_related_models, :class_name => 'RelatedModel', dependent: :destroy
   has_many :non_paranoid_models, dependent: :destroy
+  has_many :asplode_models, dependent: :destroy
 end
 
 class RelatedModel < ActiveRecord::Base
@@ -448,6 +708,10 @@ class CustomColumnModel < ActiveRecord::Base
   acts_as_paranoid column: :destroyed_at
 end
 
+class CustomSentinelModel < ActiveRecord::Base
+  acts_as_paranoid sentinel_value: DateTime.new(0)
+end
+
 class NonParanoidModel < ActiveRecord::Base
 end
 
@@ -464,3 +728,43 @@ end
 class ParanoidModelWithoutObservers < ParanoidModel
   self.class.send(remove_method :notify_observers) if method_defined?(:notify_observers)
 end
+
+# refer back to regression test for #118
+class ParanoidModelWithHasOne < ParanoidModel
+  has_one :paranoid_model_with_belong, :dependent => :destroy
+  has_one :class_name_belong, :dependent => :destroy, :class_name => "ParanoidModelWithAnthorClassNameBelong"
+  has_one :paranoid_model_with_foreign_key_belong, :dependent => :destroy, :foreign_key => "has_one_foreign_key_id"
+end
+
+class ParanoidModelWithBelong < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :paranoid_model_with_has_one
+end
+
+class ParanoidModelWithAnthorClassNameBelong < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :paranoid_model_with_has_one
+end
+
+class ParanoidModelWithForeignKeyBelong < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :paranoid_model_with_has_one
+end
+
+class FlaggedModel < PlainModel
+  acts_as_paranoid :flag_column => :is_deleted
+end
+
+class FlaggedModelWithCustomIndex < PlainModel
+  acts_as_paranoid :flag_column => :is_deleted, :indexed_column => :is_deleted
+end
+
+class AsplodeModel < ActiveRecord::Base
+  acts_as_paranoid
+  before_destroy do |r|
+    raise StandardError, 'ASPLODE!'
+  end
+end
+
+class IdlessModel < ActiveRecord::Base
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paranoia
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - radarlistener@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-16 00:00:00.000000000 Z
+date: 2014-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -70,6 +70,7 @@ files:
 - README.md
 - Rakefile
 - lib/paranoia.rb
+- lib/paranoia/rspec.rb
 - lib/paranoia/version.rb
 - paranoia.gemspec
 - test/paranoia_test.rb
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: paranoia
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much,