paranoia 1.3.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1bf4edf194a7572da8b0edc79105f4c62a37bfd2
-  data.tar.gz: dd084504c6c843de8ab3f7970570db894feac1ca
+  metadata.gz: 9e9ddf3be1c331ce833d233557bdf81876c68768
+  data.tar.gz: 8fb6cc8d861471436bbddda7331923395650eadb
 SHA512:
-  metadata.gz: 9162181a3e8261387eefdfa78a512c0eee6fef54d19e2455673cb4b96f1fd673b8531b3357a1501967360610ae7b0cefecbe75cee06ae732af331639e7012535
-  data.tar.gz: 66b30b12969246dc8c820c32bc4a4df0f817ffa00ab99a48fcd152e9e9fcf503f5d1a2dce271b154bd11a15d3c1a61a39a6678c520036f006d900e79215cc396
+  metadata.gz: 086ef0efc989048c0c41c1f00127664cfedf49a4c356e3315f1e87bf7b5d4bdd48bf1d299580d31126e8fc54de84ca231318511c199ec1c4be502068a44dc060
+  data.tar.gz: ce2574eaf67cf0d570e7139f3ea5f3bd09090449f55d577f955182661cc6204b62a7188d24dbf44422ca423ed6da126e654a6bd5bf1a005ab978f33e0a092c48

data/Gemfile

@@ -1,13 +1,4 @@
-source 'https://rubygems.org'
-
-gem 'sqlite3', :platforms => [:ruby]
-gem 'activerecord-jdbcsqlite3-adapter', :platforms => [:jruby]
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'rubysl-test-unit'
-  gem 'rubinius-developer_tools'
-end
+source :gemcutter
 
 # Specify your gem's dependencies in paranoia.gemspec
 gemspec

data/README.md

@@ -4,30 +4,12 @@ Paranoia is a re-implementation of [acts\_as\_paranoid](http://github.com/techno
 
 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.
 
-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'
-```
-
-For Rails 4, please use version 2 of Paranoia:
-
-```ruby
-gem 'paranoia', '~> 2.0'
-```
-
-Of course you can install this from GitHub as well:
+Put this in your Gemfile:
 
 ```ruby
-gem 'paranoia', :github => 'radar/paranoia', :branch => 'rails3'
-# or
-gem 'paranoia', :github => 'radar/paranoia', :branch => 'rails4'
+gem 'paranoia'
 ```
 
 Then run:
@@ -43,7 +25,7 @@ Updating is as simple as `bundle update paranoia`.
 Run:
 
 ```shell
-rails generate migration AddDeletedAtToClients deleted_at:datetime:index
+rails generate migration AddDeletedAtToClients deleted_at:datetime
 ```
 
 and now you have a migration
@@ -52,7 +34,6 @@ and now you have a migration
 class AddDeletedAtToClients < ActiveRecord::Migration
   def change
     add_column :clients, :deleted_at, :datetime
-    add_index :clients, :deleted_at
   end
 end
 ```
@@ -69,23 +50,9 @@ class Client < ActiveRecord::Base
 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]
-```
+Hey presto, it's there!
 
-If you really want it gone *gone*, call `destroy!`
-
-```
->> client.deleted_at => nil
->> client.destroy! => client
-```
-
-If you want a method to be called on destroy, simply provide a `before_destroy` callback:
+If you want a method to be called on destroy, simply provide a _before\_destroy_ callback:
 
 ```ruby
 class Client < ActiveRecord::Base
@@ -101,70 +68,6 @@ class Client < ActiveRecord::Base
 end
 ```
 
-If you want to use a column other than `deleted_at`, you can pass it as an option:
-
-```ruby
-class Client < ActiveRecord::Base
-  acts_as_paranoid column: :destroyed_at
-
-  ...
-end
-```
-
-If you want to access soft-deleted associations, override the getter method:
-
-```ruby
-def product
-  Product.unscoped { super }
-end
-```
-
-If you want to find all records, even those which are deleted:
-
-```ruby
-Client.with_deleted
-```
-
-If you want to find only the deleted records:
-
-```ruby
-Client.only_deleted
-```
-
-If you want to check if a record is soft-deleted:
-
-```ruby
-client.destroyed?
-```
-
-If you want to restore a record:
-
-```ruby
-Client.restore(id)
-```
-
-If you want to restore a whole bunch of records:
-
-```ruby
-Client.restore([id1, id2, ..., idN])
-```
-
-If you want to restore a record and their dependently destroyed associated records:
-
-```ruby
-Client.restore(id, :recursive => true)
-```
-
-If you want callbacks to trigger before a restore:
-
-```ruby
-before_restore :callback_name_goes_here
-```
-
-For more information, please look at the tests.
-
-## Acts As Paranoid Migration
-
 You can replace the older acts_as_paranoid methods as follows:
 
 | Old Syntax                 | New Syntax                     |

data/lib/paranoia.rb

@@ -1,162 +1,49 @@
-require 'active_record' unless defined? ActiveRecord
-
 module Paranoia
   def self.included(klazz)
     klazz.extend Query
-    klazz.extend Callbacks
   end
 
   module Query
-    def paranoid?
-      true
-    end
-
-
-    def with_deleted
-      scoped.tap { |x| x.default_scoped = false }
-    end
+    def paranoid? ; true ; end
 
     def only_deleted
-      with_deleted.where("#{self.table_name}.#{paranoia_column} IS NOT NULL")
-    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
+      all.tap { |x| x.default_scoped = false }.where.not(deleted_at: nil)
     end
-  end
 
-  module Callbacks
-    def self.extended(klazz)
-      klazz.define_callbacks :restore
-
-      klazz.define_singleton_method("before_restore") do |*args, &block|
-        set_callback(:restore, :before, *args, &block)
-      end
-
-      klazz.define_singleton_method("around_restore") do |*args, &block|
-        set_callback(:restore, :around, *args, &block)
-      end
-
-      klazz.define_singleton_method("after_restore") do |*args, &block|
-        set_callback(:restore, :after, *args, &block)
-      end
+    def with_deleted
+      all.tap { |x| x.default_scoped = false }
     end
   end
 
   def destroy
-    callbacks_result = run_callbacks(:destroy) { touch_paranoia_column(true) }
-    callbacks_result ? self : false
+    run_callbacks(:destroy) { delete }
   end
 
   def delete
-    return if new_record?
-    touch_paranoia_column(false)
+    return if new_record? or destroyed?
+    update_column :deleted_at, Time.now
   end
 
-  def restore!(opts = {})
-    ActiveRecord::Base.transaction do
-      run_callbacks(:restore) do
-        update_column paranoia_column, nil
-        restore_associated_records if opts[:recursive]
-      end
-    end
+  def restore!
+    update_column :deleted_at, nil
   end
-  alias :restore :restore!
 
   def destroyed?
-    !!send(paranoia_column)
+    !self.deleted_at.nil?
   end
-
   alias :deleted? :destroyed?
-
-  private
-
-  # touch paranoia column.
-  # 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
-  def restore_associated_records
-    destroyed_associations = self.class.reflect_on_all_associations.select do |association|
-      association.options[:dependent] == :destroy
-    end
-
-    destroyed_associations.each do |association|
-      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
-    end
-  end
 end
 
 class ActiveRecord::Base
-  def self.acts_as_paranoid(options={})
-    alias :really_destroyed? :destroyed?
-    alias :ar_destroy :destroy
-    alias :destroy! :ar_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
-
+  def self.acts_as_paranoid
+    alias :destroy! :destroy
+    alias :delete!  :delete
     include Paranoia
-    class_attribute :paranoia_column
-
-    self.paranoia_column = options[:column] || :deleted_at
-    default_scope { where(self.quoted_table_name + ".#{paranoia_column} IS NULL") }
-
-    before_restore {
-      self.class.notify_observers(:before_restore, self) if self.class.respond_to?(:notify_observers)
-    }
-    after_restore {
-      self.class.notify_observers(:after_restore, self) if self.class.respond_to?(:notify_observers)
-    }
+    default_scope { where(:deleted_at => nil) }
   end
 
-  def self.paranoid?
-    false
-  end
-
-  def paranoid?
-    self.class.paranoid?
-  end
+  def self.paranoid? ; false ; end
+  def paranoid? ; self.class.paranoid? ; end
 
   # Override the persisted method to allow for the paranoia gem.
   # If a paranoid record is selected, then we only want to check
@@ -164,12 +51,4 @@ class ActiveRecord::Base
   def persisted?
     paranoid? ? !new_record? : super
   end
-
-  private
-
-  def paranoia_column
-    self.class.paranoia_column
-  end
 end
-
-require 'paranoia/rspec' if defined? RSpec

data/lib/paranoia/version.rb

@@ -1,3 +1,3 @@
 module Paranoia
-  VERSION = '1.3.4'
+  VERSION = "2.0.0"
 end

data/paranoia.gemspec

@@ -1,25 +1,26 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/paranoia/version', __FILE__)
+require File.expand_path("../lib/paranoia/version", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = 'paranoia'
-  s.version = Paranoia::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.authors = %w(radarlistener@gmail.com)
-  s.email = []
-  s.homepage = 'http://rubygems.org/gems/paranoia'
-  s.summary = 'Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much, much, much less code.'
+  s.name        = "paranoia"
+  s.version     = Paranoia::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["radarlistener@gmail.com"]
+  s.email       = []
+  s.homepage    = "http://rubygems.org/gems/paranoia"
+  s.summary     = "Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much, much, much less code."
   s.description = "Paranoia is a re-implementation of 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."
 
-  s.required_rubygems_version = '>= 1.3.6'
-  s.rubyforge_project = 'paranoia'
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "paranoia"
 
-  s.add_dependency 'activerecord', '~> 3.1'
+  s.add_dependency "activerecord", "~> 4.0"
 
-  s.add_development_dependency 'bundler', '>= 1.0.0'
-  s.add_development_dependency 'rake'
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rake", "0.8.7"
 
-  s.files = `git ls-files`.split("\n")
-  s.executables = `git ls-files`.split("\n").map { |f| f =~ /^bin\/(.*)/ ? $1 : nil }.compact
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
   s.require_path = 'lib'
 end

data/test/paranoia_test.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'active_record'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/paranoia')
+require File.expand_path(File.dirname(__FILE__) + "/../lib/paranoia")
 
 DB_FILE = 'tmp/test_db'
 
@@ -10,17 +10,13 @@ FileUtils.rm_f DB_FILE
 ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => DB_FILE
 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 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 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)'
 
 class ParanoiaTest < Test::Unit::TestCase
   def test_plain_model_class_is_not_paranoid
@@ -63,37 +59,6 @@ class ParanoiaTest < Test::Unit::TestCase
     assert_equal 0, model.class.unscoped.count
   end
 
-  # Anti-regression test for #81, which would've introduced a bug to break this test.
-  def test_destroy_behavior_for_plain_models_callbacks
-    model = CallbackModel.new
-    model.save
-    model.remove_called_variables     # clear called callback flags
-    model.destroy
-
-    assert_equal nil, model.instance_variable_get(:@update_callback_called)
-    assert_equal nil, model.instance_variable_get(:@save_callback_called)
-    assert_equal nil, model.instance_variable_get(:@validate_called)
-
-    assert model.instance_variable_get(:@destroy_callback_called)
-    assert model.instance_variable_get(:@after_destroy_callback_called)
-    assert model.instance_variable_get(:@after_commit_callback_called)
-  end
-
-
-  def test_delete_behavior_for_plain_models_callbacks
-    model = CallbackModel.new
-    model.save
-    model.remove_called_variables     # clear called callback flags
-    model.delete
-
-    assert_equal nil, model.instance_variable_get(:@update_callback_called)
-    assert_equal nil, model.instance_variable_get(:@save_callback_called)
-    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)
-  end
-
   def test_destroy_behavior_for_paranoid_models
     model = ParanoidModel.new
     assert_equal 0, model.class.count
@@ -102,12 +67,11 @@ class ParanoiaTest < Test::Unit::TestCase
     model.destroy
 
     assert_equal false, model.deleted_at.nil?
-    assert_equal false, model.really_destroyed?
 
     assert_equal 0, model.class.count
     assert_equal 1, model.class.unscoped.count
   end
-
+  
   def test_scoping_behavior_for_paranoid_models
     ParanoidModel.unscoped.delete_all
     parent1 = ParentModel.create
@@ -118,27 +82,9 @@ class ParanoiaTest < Test::Unit::TestCase
     p2.destroy
     assert_equal 0, parent1.paranoid_models.count
     assert_equal 1, parent1.paranoid_models.only_deleted.count
-    assert_equal 1, parent1.paranoid_models.deleted.count
     p3 = ParanoidModel.create(:parent_model => parent1)
     assert_equal 2, parent1.paranoid_models.with_deleted.count
-    assert_equal [p1, p3], parent1.paranoid_models.with_deleted
-  end
-
-  def test_destroy_behavior_for_custom_column_models
-    model = CustomColumnModel.new
-    assert_equal 0, model.class.count
-    model.save!
-    assert_nil model.destroyed_at
-    assert_equal 1, model.class.count
-    model.destroy
-
-    assert_equal false, model.destroyed_at.nil?
-    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
+    assert_equal [p1,p3], parent1.paranoid_models.with_deleted
   end
 
   def test_destroy_behavior_for_featureful_paranoid_models
@@ -156,8 +102,8 @@ class ParanoiaTest < Test::Unit::TestCase
 
   # Regression test for #24
   def test_chaining_for_paranoid_models
-    scope = FeaturefulModel.where(:name => 'foo').only_deleted
-    assert_equal 'foo', scope.where_values_hash['name']
+    scope = FeaturefulModel.where(:name => "foo").only_deleted
+    assert_equal "foo", scope.where_values_hash['name']
     assert_equal 2, scope.where_values.count
   end
 
@@ -170,7 +116,6 @@ class ParanoiaTest < Test::Unit::TestCase
 
     assert_equal model, ParanoidModel.only_deleted.last
     assert_equal false, ParanoidModel.only_deleted.include?(model2)
-    assert_equal false, ParanoidModel.deleted.include?(model2)
   end
 
   def test_default_scope_for_has_many_relationships
@@ -218,14 +163,14 @@ class ParanoiaTest < Test::Unit::TestCase
     model = CallbackModel.new
     model.save
     model.delete
-    assert_equal nil, model.instance_variable_get(:@destroy_callback_called)
+    assert_equal nil, model.instance_variable_get(:@callback_called)
   end
 
   def test_destroy_behavior_for_callbacks
     model = CallbackModel.new
     model.save
     model.destroy
-    assert model.instance_variable_get(:@destroy_callback_called)
+    assert model.instance_variable_get(:@callback_called)
   end
 
   def test_restore
@@ -243,201 +188,25 @@ class ParanoiaTest < Test::Unit::TestCase
     assert_equal false, model.destroyed?
   end
 
-  # Regression test for #92
-  def test_destroy_twice
-    model = ParanoidModel.new
-    model.save
-    model.destroy
-    model.destroy
-
-    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
-    id = model.id
-    model.destroy
-
-    assert model.destroyed?
-
-    model = CallbackModel.only_deleted.find(id)
-    model.restore!
-    model.reload
-
-    assert model.instance_variable_get(:@restore_callback_called)
-  end
-
-  def test_really_destroy
-    model = ParanoidModel.new
-    model.save
-    model.destroy!
-
-    assert_equal 0, ParanoidModel.unscoped.where(id: model.id).count
-  end
-
-  def test_really_destroyed
+  def test_real_destroy
     model = ParanoidModel.new
     model.save
     model.destroy!
 
-    assert model.really_destroyed?
-  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)
+    refute ParanoidModel.unscoped.exists?(model.id)
   end
 
   def test_real_delete
     model = ParanoidModel.new
     model.save
     model.delete!
-    assert_equal 0, ParanoidModel.unscoped.where(id: model.id).count
-  end
-
-  def test_multiple_restore
-    a = ParanoidModel.new
-    a.save
-    a_id = a.id
-    a.destroy
-
-    b = ParanoidModel.new
-    b.save
-    b_id = b.id
-    b.destroy
-
-    c = ParanoidModel.new
-    c.save
-    c_id = c.id
-    c.destroy
-
-    ParanoidModel.restore([a_id, c_id])
-
-    a.reload
-    b.reload
-    c.reload
-
-    refute a.destroyed?
-    assert b.destroyed?
-    refute c.destroyed?
-  end
-
-  def test_restore_with_associations
-    parent = ParentModel.create
-    first_child = parent.very_related_models.create
-    second_child = parent.non_paranoid_models.create
-
-    parent.destroy
-    assert_equal false, parent.deleted_at.nil?
-    assert_equal false, first_child.reload.deleted_at.nil?
-    assert_equal true, second_child.destroyed?
-
-    parent.restore!
-    assert_equal true, parent.deleted_at.nil?
-    assert_equal false, first_child.reload.deleted_at.nil?
-    assert_equal true, second_child.destroyed?
-
-    parent.destroy
-    parent.restore(:recursive => true)
-    assert_equal true, parent.deleted_at.nil?
-    assert_equal true, first_child.reload.deleted_at.nil?
-    assert_equal true, second_child.destroyed?
-
-    parent.destroy
-    ParentModel.restore(parent.id, :recursive => true)
-    assert_equal true, parent.reload.deleted_at.nil?
-    assert_equal true, first_child.reload.deleted_at.nil?
-    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
-    hasOne.paranoid_model_with_belong = belongsTo
-    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"
-  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
-
-  def test_observers_notified
-    a = ParanoidModelWithObservers.create
-    a.destroy
-    a.restore!
 
-    assert a.observers_notified.select {|args| args == [:before_restore, a]}
-    assert a.observers_notified.select {|args| args == [:after_restore, a]}
-  end
-
-  def test_observers_not_notified_if_not_supported
-    a = ParanoidModelWithObservers.create
-    a.destroy
-    a.restore!
-    # essentially, we're just ensuring that this doesn't crash
+    refute ParanoidModel.unscoped.exists?(model.id)
   end
 
   private
   def get_featureful_model
-    FeaturefulModel.new(:name => 'not empty')
+    FeaturefulModel.new(:name => "not empty")
   end
 end
 
@@ -452,13 +221,6 @@ 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
@@ -469,26 +231,12 @@ end
 
 class CallbackModel < ActiveRecord::Base
   acts_as_paranoid
-  before_destroy {|model| model.instance_variable_set :@destroy_callback_called, true }
-  before_restore {|model| model.instance_variable_set :@restore_callback_called, true }
-  before_update  {|model| model.instance_variable_set :@update_callback_called, true }
-  before_save    {|model| model.instance_variable_set :@save_callback_called, true}
-
-  after_destroy  {|model| model.instance_variable_set :@after_destroy_callback_called, true }
-  after_commit   {|model| model.instance_variable_set :@after_commit_callback_called, true }
-
-  validate       {|model| model.instance_variable_set :@validate_called, true }
-
-  def remove_called_variables
-    instance_variables.each {|name| (name.to_s.end_with?('_called')) ? remove_instance_variable(name) : nil}
-  end
+  before_destroy {|model| model.instance_variable_set :@callback_called, true }
 end
 
 class ParentModel < ActiveRecord::Base
   acts_as_paranoid
   has_many :related_models
-  has_many :very_related_models, :class_name => 'RelatedModel', dependent: :destroy
-  has_many :non_paranoid_models, dependent: :destroy
 end
 
 class RelatedModel < ActiveRecord::Base
@@ -513,34 +261,3 @@ class Job < ActiveRecord::Base
   belongs_to :employer
   belongs_to :employee
 end
-
-class CustomColumnModel < ActiveRecord::Base
-  acts_as_paranoid column: :destroyed_at
-end
-
-class NonParanoidModel < ActiveRecord::Base
-end
-
-class ParanoidModelWithObservers < ParanoidModel
-  def observers_notified
-    @observers_notified ||= []
-  end
-
-  def self.notify_observer(*args)
-    observers_notified << args
-  end
-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
-end
-
-class ParanoidModelWithBelong < ActiveRecord::Base
-  acts_as_paranoid
-  belongs_to :paranoid_model_with_has_one
-end

metadata

@@ -1,57 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: paranoia
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 2.0.0
 platform: ruby
 authors:
 - radarlistener@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-29 00:00:00.000000000 Z
+date: 2013-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
 description: Paranoia is a re-implementation of 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
@@ -63,14 +77,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/paranoia.rb
-- lib/paranoia/rspec.rb
 - lib/paranoia/version.rb
 - paranoia.gemspec
 - test/paranoia_test.rb
@@ -83,17 +95,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: paranoia
-rubygems_version: 2.2.2
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Paranoia is a re-implementation of acts_as_paranoid for Rails 3, using much,

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - jruby-19mode
-  - rbx

data/lib/paranoia/rspec.rb

@@ -1,13 +0,0 @@
-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