rails3_acts_as_paranoid_create 0.2.0

data/.gitignore

@@ -0,0 +1,4 @@
+pkg
+.bundle
+.rvmrc
+vendor

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails3_acts_as_paranoid.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    rails3_acts_as_paranoid_create (0.2.0)
+      activerecord (~> 3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.0)
+      activesupport (= 3.1.0)
+      bcrypt-ruby (~> 3.0.0)
+      builder (~> 3.0.0)
+      i18n (~> 0.6)
+    activerecord (3.1.0)
+      activemodel (= 3.1.0)
+      activesupport (= 3.1.0)
+      arel (~> 2.2.1)
+      tzinfo (~> 0.3.29)
+    activesupport (3.1.0)
+      multi_json (~> 1.0)
+    arel (2.2.1)
+    bcrypt-ruby (3.0.0)
+    builder (3.0.0)
+    i18n (0.6.0)
+    multi_json (1.0.3)
+    rake (0.9.2)
+    rdoc (3.9.4)
+    sqlite3 (1.3.4)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+    tzinfo (0.3.29)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (>= 3.1.0)
+  rails3_acts_as_paranoid_create!
+  rake (>= 0.9.0)
+  rdoc (>= 3.9.0)
+  sqlite3-ruby (>= 1.3.0)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Gonçalo Silva
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,120 @@
+# ActsAsParanoid
+
+A simple plugin which hides records instead of deleting them, being able to recover them.
+
+## 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:
+
+    class Paranoiac < ActiveRecord::Base
+      acts_as_paranoid
+    end
+
+### Options
+
+You can also specify the name of the column to store it's *deletion* and the type of data it holds:
+
+-   :column => 'deleted_at'
+-   :type => 'time'
+
+The values shown are the defaults. While *column* can be anything (as long as it exists in your database), *type* is restricted to "boolean", "time" or "string".
+
+If your column type is a "string", you can also specify which value to use when marking an object as deleted by passing `:deleted_value` (default is "deleted").
+
+### Filtering
+
+If a record is deleted by ActsAsParanoid, it won't be retrieved when accessing the database. So, `Paranoiac.all` will **not** include the deleted_records. if you want to access them, you have 2 choices:
+
+    Paranoiac.only_deleted # retrieves the deleted records
+    Paranoiac.with_deleted # retrieves all records, deleted or not
+
+### Real deletion
+
+In order to really delete a record, just use:
+
+    paranoiac.destroy!
+    Paranoiac.delete_all!(conditions)
+
+You can also definitively delete a record by calling `destroy` or `delete_all` on it twice. If a record was already deleted (hidden by ActsAsParanoid) and you delete it again, it will be removed from the database. Take this example:
+
+    Paranoiac.first.destroy # does NOT delete the first record, just hides it
+    Paranoiac.only_deleted.destroy # deletes the first record from the database
+
+### Recovery
+
+Recovery is easy. Just invoke `recover` on it, like this:
+
+    Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover
+    
+All associations marked as `:dependent => :destroy` are also recursively recovered. If you would like to disable this behavior, you can call `recover` with the `recursive` option:
+
+    Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover(:recursive => false)
+
+If you would like to change the default behavior for a model, you can use the `recover_dependent_associations` option
+
+    class Paranoiac < ActiveRecord::Base
+        acts_as_paranoid :recover_dependent_associations => false
+    end
+
+By default when using timestamp fields to mark deletion, dependent records will be recovered if they were deleted within 5 seconds of the object upon which they depend.  This restores the objects to the state before the recursive deletion without restoring other objects that were deleted earlier.  This window can be changed with the `dependent_recovery_window` option
+
+    class Paranoiac < ActiveRecord::Base
+        acts_as_paranoid
+        has_many :paranoids, :dependent => :destroy
+    end
+
+    class Paranoid < ActiveRecord::Base
+        belongs_to :paranoic
+
+        # Paranoid objects will be recovered alongside Paranoic objects 
+        # if they were deleted within 1 minute of the Paranoic object
+        acts_as_paranoid :dependent_recovery_window => 1.minute
+    end
+
+or in the recover statement
+
+    Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover(:recovery_window => 30.seconds)
+
+### Validation
+ActiveRecord's built-in uniqueness validation does not account for records deleted by ActsAsParanoid. If you want to check for uniqueness among non-deleted records only, use the macro `validates_as_paranoid` in your model. Then, instead of using `validates_uniqueness_of`, use `validates_uniqueness_of_without_deleted`. This will keep deleted records from counting against the uniqueness check.
+
+    class Paranoiac < ActiveRecord::Base
+      acts_as_paranoid
+      validates_as_paranoid
+      validates_uniqueness_of_without_deleted :name
+    end
+  
+    Paranoiac.create(:name => 'foo').destroy
+    Paranoiac.new(:name => 'foo').valid? #=> true
+    
+
+### Status
+Once you retrieve data using `with_deleted` scope you can check deletion status using `deleted?` helper:
+
+    Paranoiac.create(:name => 'foo').destroy
+    Paranoiac.with_deleted.first.deleted? #=> true
+
+## Caveats
+
+Watch out for these caveats:
+
+-   You cannot use default\_scope in your model. It is possible to work around this caveat, but it's not pretty. Have a look at [this article](http://joshuaclayton.github.com/code/default_scope/activerecord/is_paranoid/multiple-default-scopes.html) if you really need to have your own default scope.
+-   You cannot use scopes named `with_deleted`, `only_deleted` and `paranoid_deleted_around_time`
+-   `unscoped` will return all records, deleted or not
+
+## Acknowledgements
+
+* To [cheerfulstoic](https://github.com/cheerfulstoic) for adding recursive recovery
+* To [Jonathan Vaught](https://github.com/gravelpup) for adding paranoid validations
+* To [Geoffrey Hichborn](https://github.com/phene) for improving the overral code quality and adding support for after_commit
+* To [flah00](https://github.com/flah00) for adding support for STI-based associations (with :dependent)
+* To [vikramdhillon](https://github.com/vikramdhillon) for the idea and
+  initial implementation of support for string column type
+
+Copyright © 2010 Gonçalo Silva, released under the MIT license

data/Rakefile

@@ -0,0 +1,48 @@
+require('bundler/gem_tasks')
+require "rake/testtask"
+require "rdoc/task"
+
+gemspec = eval(File.read(Dir["*.gemspec"].first))
+
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the rails3_acts_as_paranoid plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the rails3_acts_as_paranoid plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsParanoid'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc "Build gem locally"
+task :build => :gemspec do
+  system "gem build #{gemspec.name}.gemspec"
+  FileUtils.mkdir_p "pkg"
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", "pkg"
+end
+
+desc "Install gem locally"
+task :install => :build do
+  system "gem install pkg/#{gemspec.name}-#{gemspec.version}"
+end
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+end

data/init.rb

@@ -0,0 +1 @@
+require 'rails3_acts_as_paranoid'

data/lib/rails3_acts_as_paranoid.rb

@@ -0,0 +1,197 @@
+require 'active_record'
+require 'validations/uniqueness_without_deleted'
+
+module ActsAsParanoid
+  
+  def paranoid?
+    self.included_modules.include?(InstanceMethods)
+  end
+  
+  def validates_as_paranoid
+    extend ParanoidValidations::ClassMethods
+  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
+
+    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?
+
+    ActiveRecord::Relation.class_eval do
+      alias_method :delete_all!, :delete_all
+      alias_method :destroy!, :destroy
+    end
+    
+    scope :not_deleted, where("#{paranoid_column_reference} IS ?", nil)
+    
+    scope :paranoid_deleted_around_time, lambda {|value, window|
+      if self.class.respond_to?(:paranoid?) && self.class.paranoid?
+        if self.class.paranoid_column_type == 'time' && ![true, false].include?(value)
+          self.where("#{self.class.paranoid_column} > ? AND #{self.class.paranoid_column} < ?", (value - window), (value + window))
+        else
+          self.only_deleted
+        end
+      end if paranoid_configuration[:column_type] == 'time'
+    }
+    
+    include InstanceMethods
+    extend ClassMethods
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      base.define_callbacks :recover
+    end
+
+    def before_recover(method)
+      set_callback :recover, :before, method
+    end
+
+    def after_recover(method)
+      set_callback :recover, :after, method
+    end
+
+    def with_deleted
+      self.unscoped
+    end
+
+    def only_deleted
+      self.unscoped.where("#{paranoid_column_reference} IS NOT ?", nil)
+    end
+
+    def delete_all!(conditions = nil)
+      self.unscoped.delete_all!(conditions)
+    end
+
+    def delete_all(conditions = nil)
+      update_all ["#{paranoid_configuration[:column]} = ?", delete_now_value], conditions
+    end
+
+    def paranoid_column
+      paranoid_configuration[:column].to_sym
+    end
+
+    def paranoid_column_type
+      paranoid_configuration[:column_type].to_sym
+    end
+
+    def dependent_associations
+      self.reflect_on_all_associations.select {|a| [:destroy, :delete_all].include?(a.options[:dependent]) }
+    end
+
+    def delete_now_value
+      case paranoid_configuration[:column_type]
+        when "time" then Time.now
+        when "boolean" then true
+        when "string" then paranoid_configuration[:deleted_value]
+      end
+    end
+  end
+  
+  module InstanceMethods
+    
+    def paranoid_value
+      self.send(self.class.paranoid_column)
+    end
+    
+    def destroy!
+      with_transaction_returning_status do
+        run_callbacks :destroy do
+          act_on_dependent_destroy_associations
+          self.class.delete_all!(:id => self.id)
+          self.paranoid_value = self.class.delete_now_value
+          freeze
+        end
+      end
+    end
+
+    def destroy
+      if paranoid_value.nil?
+        with_transaction_returning_status do
+          run_callbacks :destroy do
+            self.class.delete_all(:id => self.id)
+            self.paranoid_value = self.class.delete_now_value
+            self
+          end
+        end
+      else
+        destroy!
+      end
+    end
+    
+    def recover(options={})
+      options = {
+                  :recursive => self.class.paranoid_configuration[:recover_dependent_associations],
+                  :recovery_window => self.class.paranoid_configuration[:dependent_recovery_window]
+                }.merge(options)
+
+      self.class.transaction do
+        run_callbacks :recover do
+          recover_dependent_associations(options[:recovery_window], options) if options[:recursive]
+
+          self.update_attributes(self.class.paranoid_column.to_sym => nil)
+        end
+      end
+    end
+
+    def recover_dependent_associations(window, options)
+      self.class.dependent_associations.each do |association|
+        if association.collection? && self.send(association.name).paranoid?
+          self.send(association.name).unscoped do
+            self.send(association.name).paranoid_deleted_around_time(paranoid_value, window).each do |object|
+              object.recover(options) if object.respond_to?(:recover)
+            end
+          end
+        elsif association.macro == :has_one && association.klass.paranoid?
+          association.klass.unscoped do
+            object = association.klass.paranoid_deleted_around_time(paranoid_value, window).send('find_by_'+association.foreign_key, self.id)
+            object.recover(options) if object && object.respond_to?(:recover)
+          end
+        elsif association.klass.paranoid?
+          association.klass.unscoped do
+            id = self.send(association.foreign_key)
+            object = association.klass.paranoid_deleted_around_time(paranoid_value, window).find_by_id(id)
+            object.recover(options) if object && object.respond_to?(:recover)
+          end
+        end
+      end
+    end
+    
+    def act_on_dependent_destroy_associations
+      self.class.dependent_associations.each do |association|
+        if association.collection? && self.send(association.name).paranoid?
+          association.klass.with_deleted.instance_eval("find_all_by_#{association.foreign_key}(#{self.id})").each do |object|
+            object.destroy!
+          end
+        end
+      end
+    end
+
+    def deleted?
+      !paranoid_value.nil?
+    end
+    alias_method :destroyed?, :deleted?
+    
+  private
+    def paranoid_value=(value)
+      self.send("#{self.class.paranoid_column}=", value)
+    end
+    
+  end
+  
+end
+
+# Extend ActiveRecord's functionality
+ActiveRecord::Base.send :extend, ActsAsParanoid
+
+# Push the recover callback onto the activerecord callback list
+ActiveRecord::Callbacks::CALLBACKS.push(:before_recover, :after_recover)

data/lib/rails3_acts_as_paranoid/version.rb

@@ -0,0 +1,3 @@
+module Rails3ActsAsParanoid
+  VERSION = '0.2.0'
+end

data/lib/validations/uniqueness_without_deleted.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/array/wrap'
+
+module ParanoidValidations
+  class UniquenessWithoutDeletedValidator < ActiveRecord::Validations::UniquenessValidator
+    def validate_each(record, attribute, value)
+      finder_class = find_finder_class_for(record)
+
+      if value && record.class.serialized_attributes.key?(attribute.to_s)
+        value = YAML.dump value
+      end
+
+      sql, params = mount_sql_and_params(finder_class, record.class.quoted_table_name, attribute, value)
+
+      # This is the only changed line from the base class version - it does finder_class.unscoped
+      relation = finder_class.where(sql, *params)
+      
+      Array.wrap(options[:scope]).each do |scope_item|
+        scope_value = record.send(scope_item)
+        relation = relation.where(scope_item => scope_value)
+      end
+
+      if record.persisted?
+        # TODO : This should be in Arel
+        relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
+      end
+
+      if relation.exists?
+        record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+      end
+    end
+  end
+
+  module ClassMethods
+    def validates_uniqueness_of_without_deleted(*attr_names)
+      validates_with UniquenessWithoutDeletedValidator, _merge_attributes(attr_names)
+    end
+  end
+end

data/rails3_acts_as_paranoid.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push(File.expand_path('../lib', __FILE__))
+require('rails3_acts_as_paranoid/version')
+
+Gem::Specification.new do |s|
+  s.name              = "rails3_acts_as_paranoid_create"
+  s.version           = Rails3ActsAsParanoid::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = ["Goncalo Silva", "Philipp Ullmann"]
+  s.email             = ["goncalossilva@gmail.com", "philipp.ullmann@create.at"]
+  s.homepage          = "http://github.com/goncalossilva/rails3_acts_as_paranoid"
+  s.summary           = "Active Record (>=3.0) plugin which allows you to hide and restore records without actually deleting them."
+  s.description       = "Active Record (>=3.0) plugin which allows you to hide and restore records without actually deleting them. Check its GitHub page for more in-depth information."
+  s.rubyforge_project = s.name
+
+  s.required_rubygems_version = ">= 1.3.6"
+  
+  s.add_dependency "activerecord", "~> 3.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  s.add_development_dependency('rake', ['>= 0.9.0'])
+  s.add_development_dependency('sqlite3-ruby', ['>= 1.3.0'])
+  s.add_development_dependency('activesupport', ['>= 3.1.0'])
+  s.add_development_dependency('rdoc', ['>= 3.9.0'])
+end

data/test/rails3_acts_as_paranoid_test.rb

@@ -0,0 +1,295 @@
+require 'test_helper'
+
+class ParanoidBaseTest < ActiveSupport::TestCase
+  def assert_empty(collection)
+    assert(collection.respond_to?(:empty?) && collection.empty?)
+  end
+  
+  def setup
+    setup_db
+
+    ["paranoid", "really paranoid", "extremely paranoid"].each do |name|
+      ParanoidTime.create! :name => name
+      ParanoidBoolean.create! :name => name
+    end
+
+    ParanoidString.create! :name => "strings can be paranoid"
+    NotParanoid.create! :name => "no paranoid goals"
+    ParanoidWithCallback.create! :name => "paranoid with callbacks"
+
+    ParanoidObserver.instance.reset
+  end
+
+  def teardown
+    teardown_db
+  end
+end
+
+class ParanoidTest < ParanoidBaseTest
+  def test_fake_removal
+    assert_equal 3, ParanoidTime.not_deleted.count
+    assert_equal 3, ParanoidBoolean.not_deleted.count
+    assert_equal 1, ParanoidString.not_deleted.count
+
+    ParanoidTime.not_deleted.first.destroy
+    ParanoidBoolean.delete_all("name = 'paranoid' OR name = 'really paranoid'")
+    ParanoidString.not_deleted.first.destroy
+    assert_equal 2, ParanoidTime.not_deleted.count
+    assert_equal 1, ParanoidBoolean.not_deleted.count
+    assert_equal 0, ParanoidString.not_deleted.count
+    assert_equal 1, ParanoidTime.only_deleted.count 
+    assert_equal 2, ParanoidBoolean.only_deleted.count
+    assert_equal 1, ParanoidString.only_deleted.count
+    assert_equal 3, ParanoidTime.with_deleted.count
+    assert_equal 3, ParanoidBoolean.with_deleted.count
+    assert_equal 1, ParanoidString.with_deleted.count
+  end
+
+  def test_real_removal
+    ParanoidTime.not_deleted.first.destroy!
+    ParanoidBoolean.delete_all!("name = 'extremely paranoid' OR name = 'really paranoid'")
+    ParanoidString.not_deleted.first.destroy!
+    assert_equal 2, ParanoidTime.not_deleted.count
+    assert_equal 1, ParanoidBoolean.not_deleted.count
+    assert_equal 0, ParanoidString.not_deleted.count
+    assert_equal 2, ParanoidTime.with_deleted.count
+    assert_equal 1, ParanoidBoolean.with_deleted.count
+    assert_equal 0, ParanoidString.with_deleted.count
+    assert_equal 0, ParanoidTime.only_deleted.count
+    assert_equal 0, ParanoidBoolean.only_deleted.count
+    assert_equal 0, ParanoidString.only_deleted.count
+
+    ParanoidTime.not_deleted.first.destroy
+    ParanoidTime.only_deleted.first.destroy
+    assert_equal 0, ParanoidTime.only_deleted.count
+
+    ParanoidTime.delete_all!
+    assert_empty ParanoidTime.not_deleted.all
+    assert_empty ParanoidTime.with_deleted.all
+  end
+
+  def test_paranoid_scope
+    assert_raise(NoMethodError) { NotParanoid.delete_all! }
+    assert_raise(NoMethodError) { NotParanoid.first.destroy! }
+    assert_raise(NoMethodError) { NotParanoid.with_deleted }
+    assert_raise(NoMethodError) { NotParanoid.only_deleted }    
+  end
+
+  def test_recovery
+    assert_equal 3, ParanoidBoolean.not_deleted.count
+    ParanoidBoolean.not_deleted.first.destroy
+    assert_equal 2, ParanoidBoolean.not_deleted.count
+    ParanoidBoolean.only_deleted.first.recover
+    assert_equal 3, ParanoidBoolean.not_deleted.count
+
+    assert_equal 1, ParanoidString.not_deleted.count
+    ParanoidString.not_deleted.first.destroy
+    assert_equal 0, ParanoidString.not_deleted.count
+    ParanoidString.with_deleted.first.recover
+    assert_equal 1, ParanoidString.not_deleted.count
+  end
+
+  def setup_recursive_recovery_tests
+    @paranoid_time_object = ParanoidTime.not_deleted.first
+
+    @paranoid_boolean_count = ParanoidBoolean.not_deleted.count
+
+    assert_equal 0, ParanoidHasManyDependant.not_deleted.count
+    assert_equal 0, ParanoidBelongsDependant.not_deleted.count
+
+    (1..3).each do |i|
+      has_many_object = @paranoid_time_object.paranoid_has_many_dependants.create(:name => "has_many_#{i}")
+      has_many_object.create_paranoid_belongs_dependant(:name => "belongs_to_#{i}")
+      has_many_object.save
+
+      paranoid_boolean = @paranoid_time_object.paranoid_booleans.create(:name => "boolean_#{i}")
+      paranoid_boolean.create_paranoid_has_one_dependant(:name => "has_one_#{i}")
+      paranoid_boolean.save
+
+      @paranoid_time_object.not_paranoids.create(:name => "not_paranoid_a#{i}")
+
+    end
+
+    @paranoid_time_object.create_not_paranoid(:name => "not_paranoid_belongs_to")
+
+    @paranoid_time_object.create_has_one_not_paranoid(:name => "has_one_not_paranoid")
+
+    assert_equal 3, ParanoidTime.not_deleted.count
+    assert_equal 3, ParanoidHasManyDependant.not_deleted.count
+    assert_equal 3, ParanoidBelongsDependant.not_deleted.count
+    assert_equal 3, ParanoidHasOneDependant.not_deleted.count
+    assert_equal 5, NotParanoid.count
+    assert_equal 1, HasOneNotParanoid.count
+    assert_equal @paranoid_boolean_count + 3, ParanoidBoolean.not_deleted.count
+
+    @paranoid_time_object.destroy
+    @paranoid_time_object.reload
+
+    assert_equal 2, ParanoidTime.not_deleted.count
+    assert_equal 0, ParanoidHasManyDependant.not_deleted.count
+    assert_equal 0, ParanoidBelongsDependant.not_deleted.count
+    assert_equal 0, ParanoidHasOneDependant.not_deleted.count
+
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+    assert_equal @paranoid_boolean_count, ParanoidBoolean.not_deleted.count
+  end
+
+  def test_recursive_recovery
+    setup_recursive_recovery_tests
+
+    @paranoid_time_object.recover(:recursive => true)
+
+    assert_equal 3, ParanoidTime.not_deleted.count
+    assert_equal 3, ParanoidHasManyDependant.not_deleted.count
+    assert_equal 3, ParanoidBelongsDependant.not_deleted.count
+    assert_equal 3, ParanoidHasOneDependant.not_deleted.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+    assert_equal @paranoid_boolean_count + 3, ParanoidBoolean.not_deleted.count
+  end
+
+  def test_non_recursive_recovery
+    setup_recursive_recovery_tests
+
+    @paranoid_time_object.recover(:recursive => false)
+
+    assert_equal 3, ParanoidTime.not_deleted.count
+    assert_equal 0, ParanoidHasManyDependant.not_deleted.count
+    assert_equal 0, ParanoidBelongsDependant.not_deleted.count
+    assert_equal 0, ParanoidHasOneDependant.not_deleted.count
+    assert_equal 1, NotParanoid.count
+    assert_equal 0, HasOneNotParanoid.count
+    assert_equal @paranoid_boolean_count, ParanoidBoolean.not_deleted.count
+  end
+
+  def test_deleted?
+    ParanoidTime.not_deleted.first.destroy
+    assert ParanoidTime.with_deleted.first.deleted?
+
+    ParanoidString.not_deleted.first.destroy
+    assert ParanoidString.with_deleted.first.deleted?
+  end
+  
+  def test_paranoid_destroy_callbacks    
+    @paranoid_with_callback = ParanoidWithCallback.not_deleted.first
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy
+    end
+    
+    assert @paranoid_with_callback.called_before_destroy
+    assert @paranoid_with_callback.called_after_destroy
+    assert @paranoid_with_callback.called_after_commit_on_destroy
+  end
+  
+  def test_hard_destroy_callbacks
+    @paranoid_with_callback = ParanoidWithCallback.not_deleted.first
+    
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy!
+    end
+    
+    assert @paranoid_with_callback.called_before_destroy
+    assert @paranoid_with_callback.called_after_destroy
+    assert @paranoid_with_callback.called_after_commit_on_destroy
+  end
+
+  def test_recovery_callbacks
+    @paranoid_with_callback = ParanoidWithCallback.not_deleted.first
+
+    ParanoidWithCallback.transaction do
+      @paranoid_with_callback.destroy
+
+      assert_nil @paranoid_with_callback.called_before_recover
+      assert_nil @paranoid_with_callback.called_after_recover
+
+      @paranoid_with_callback.recover
+    end
+
+      assert @paranoid_with_callback.called_before_recover
+      assert @paranoid_with_callback.called_after_recover    
+  end
+end
+
+class ValidatesUniquenessTest < ParanoidBaseTest
+  def test_should_include_deleted_by_default
+    ParanoidTime.new(:name => 'paranoid').tap do |record|
+      assert !record.valid?
+      ParanoidTime.not_deleted.first.destroy
+      assert !record.valid?
+      ParanoidTime.only_deleted.first.destroy!
+      assert record.valid?
+    end
+  end
+
+  def test_should_validate_without_deleted
+    ParanoidBoolean.new(:name => 'paranoid').tap do |record|
+      ParanoidBoolean.not_deleted.first.destroy
+      assert record.valid?
+      ParanoidBoolean.only_deleted.first.destroy!
+      assert record.valid?
+    end
+  end
+end
+
+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.not_deleted.count
+    assert_equal 1, ParanoidDeleteCompany.not_deleted.count
+    assert_equal 2, ParanoidProduct.not_deleted.count
+
+    ParanoidDestroyCompany.not_deleted.first.destroy
+    assert_equal 0, ParanoidDestroyCompany.not_deleted.count
+    assert_equal 1, ParanoidProduct.not_deleted.count
+    assert_equal 1, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 2, ParanoidProduct.with_deleted.count
+  
+    ParanoidDestroyCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDestroyCompany.not_deleted.count
+    assert_equal 1, ParanoidProduct.not_deleted.count
+    assert_equal 0, ParanoidDestroyCompany.with_deleted.count
+    assert_equal 1, ParanoidProduct.with_deleted.count
+    
+    ParanoidDeleteCompany.with_deleted.first.destroy!
+    assert_equal 0, ParanoidDeleteCompany.not_deleted.count
+    assert_equal 0, ParanoidProduct.not_deleted.count
+    assert_equal 0, ParanoidDeleteCompany.with_deleted.count
+    assert_equal 0, ParanoidProduct.with_deleted.count
+  end
+end
+
+class InheritanceTest < ParanoidBaseTest
+  def test_destroy_dependents_with_inheritance
+    has_many_inherited_super_paranoidz = HasManyInheritedSuperParanoidz.new
+    has_many_inherited_super_paranoidz.save
+    has_many_inherited_super_paranoidz.super_paranoidz.create
+    assert_nothing_raised(NoMethodError) { has_many_inherited_super_paranoidz.destroy }
+  end
+  
+  def test_class_instance_variables_are_inherited
+    assert_nothing_raised(ActiveRecord::StatementInvalid) { InheritedParanoid.paranoid_column }
+  end
+end
+
+class ParanoidObserverTest < ParanoidBaseTest
+
+  def test_called_observer_methods
+    @subject = ParanoidWithCallback.new
+    @subject.save
+
+    assert_nil ParanoidObserver.instance.called_before_recover
+    assert_nil ParanoidObserver.instance.called_after_recover
+    
+    ParanoidWithCallback.not_deleted.find(@subject.id).recover
+
+    assert_equal @subject, ParanoidObserver.instance.called_before_recover
+    assert_equal @subject, ParanoidObserver.instance.called_after_recover
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,271 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_record'
+require 'active_model'
+
+$:.unshift "#{File.dirname(__FILE__)}/../"
+$:.unshift "#{File.dirname(__FILE__)}/../lib/"
+$:.unshift "#{File.dirname(__FILE__)}/../lib/validations"
+
+require 'init'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+def setup_db
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :paranoid_times do |t|
+      t.string    :name
+      t.datetime  :deleted_at
+      t.integer   :paranoid_belongs_dependant_id
+      t.integer   :not_paranoid_id
+
+      t.timestamps
+    end
+
+    create_table :paranoid_booleans do |t|
+      t.string    :name
+      t.boolean   :is_deleted
+      t.integer   :paranoid_time_id
+
+      t.timestamps
+    end
+
+    create_table :paranoid_strings do |t|
+      t.string    :name
+      t.string    :deleted
+    end
+
+    create_table :not_paranoids do |t|
+      t.string    :name
+      t.integer   :paranoid_time_id
+
+      t.timestamps
+    end
+
+    create_table :has_one_not_paranoids do |t|
+      t.string    :name
+      t.integer   :paranoid_time_id
+
+      t.timestamps
+    end
+
+    create_table :paranoid_has_many_dependants do |t|
+      t.string    :name
+      t.datetime  :deleted_at
+      t.integer   :paranoid_time_id
+      t.integer   :paranoid_belongs_dependant_id
+
+      t.timestamps
+    end
+
+    create_table :paranoid_belongs_dependants do |t|
+      t.string    :name
+      t.datetime  :deleted_at
+
+      t.timestamps
+    end
+
+    create_table :paranoid_has_one_dependants do |t|
+      t.string    :name
+      t.datetime  :deleted_at
+      t.integer   :paranoid_boolean_id
+
+      t.timestamps
+    end
+    
+    create_table :paranoid_with_callbacks do |t|
+      t.string    :name
+      t.datetime  :deleted_at
+      
+      t.timestamps
+    end
+
+    create_table :paranoid_destroy_companies do |t|
+      t.string :name
+      t.datetime :deleted_at
+      
+      t.timestamps
+    end
+    
+    create_table :paranoid_delete_companies do |t|
+      t.string :name
+      t.datetime :deleted_at
+      
+      t.timestamps
+    end
+    
+    create_table :paranoid_products do |t|
+      t.integer :paranoid_destroy_company_id
+      t.integer :paranoid_delete_company_id
+      t.string :name
+      t.datetime :deleted_at
+      
+      t.timestamps
+    end
+    
+    create_table :super_paranoids do |t|
+      t.string :type
+      t.references :has_many_inherited_super_paranoidz
+      t.datetime :deleted_at
+      
+      t.timestamps
+    end
+    
+    create_table :has_many_inherited_super_paranoidzs do |t|
+      t.references :super_paranoidz
+      t.datetime :deleted_at
+      
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class ParanoidTime < ActiveRecord::Base
+  acts_as_paranoid
+  validates_uniqueness_of :name
+
+  has_many :paranoid_has_many_dependants, :dependent => :destroy
+  has_many :paranoid_booleans, :dependent => :destroy
+  has_many :not_paranoids, :dependent => :delete_all
+
+  has_one :has_one_not_paranoid, :dependent => :destroy
+
+  belongs_to :not_paranoid, :dependent => :destroy
+end
+
+class ParanoidBoolean < ActiveRecord::Base
+  acts_as_paranoid :column_type => "boolean", :column => "is_deleted"
+  validates_as_paranoid
+
+  belongs_to :paranoid_time
+  has_one :paranoid_has_one_dependant, :dependent => :destroy
+end
+
+class ParanoidString < ActiveRecord::Base
+  acts_as_paranoid :column_type => "string", :column => "deleted", :deleted_value => "dead"
+end
+
+class NotParanoid < ActiveRecord::Base
+end
+
+class HasOneNotParanoid < ActiveRecord::Base
+end
+
+class ParanoidHasManyDependant < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :paranoid_time
+
+  belongs_to :paranoid_belongs_dependant, :dependent => :destroy
+end
+
+class ParanoidBelongsDependant < ActiveRecord::Base
+  acts_as_paranoid
+
+  has_many :paranoid_has_many_dependants
+end
+
+class ParanoidHasOneDependant < ActiveRecord::Base
+  acts_as_paranoid
+
+  belongs_to :paranoid_boolean
+end
+
+class ParanoidWithCallback < ActiveRecord::Base
+  acts_as_paranoid
+  
+  attr_accessor :called_before_destroy, :called_after_destroy, :called_after_commit_on_destroy
+  attr_accessor :called_before_recover, :called_after_recover
+  
+  before_destroy :call_me_before_destroy
+  after_destroy :call_me_after_destroy
+  
+  after_commit :call_me_after_commit_on_destroy, :on => :destroy
+
+  before_recover :call_me_before_recover
+  after_recover :call_me_after_recover
+  
+  def initialize(*attrs)
+    @called_before_destroy = @called_after_destroy = @called_after_commit_on_destroy = false
+    super(*attrs)
+  end
+  
+  def call_me_before_destroy
+    @called_before_destroy = true
+  end
+  
+  def call_me_after_destroy
+    @called_after_destroy = true
+  end
+  
+  def call_me_after_commit_on_destroy
+    @called_after_commit_on_destroy = true
+  end
+
+  def call_me_before_recover
+    @called_before_recover = true
+  end
+
+  def call_me_after_recover
+    @called_after_recover = true
+  end
+end
+
+class ParanoidDestroyCompany < ActiveRecord::Base
+  acts_as_paranoid
+  validates :name, :presence => true
+  has_many :paranoid_products, :dependent => :destroy
+end
+
+class ParanoidDeleteCompany < ActiveRecord::Base
+  acts_as_paranoid
+  validates :name, :presence => true
+  has_many :paranoid_products, :dependent => :delete_all
+end
+
+class ParanoidProduct < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :paranoid_destroy_company
+  belongs_to :paranoid_delete_company
+  validates_presence_of :name
+end
+
+class SuperParanoid < ActiveRecord::Base
+  acts_as_paranoid
+  belongs_to :has_many_inherited_super_paranoidz
+end
+
+class HasManyInheritedSuperParanoidz < ActiveRecord::Base
+  has_many :super_paranoidz, :class_name => "InheritedParanoid", :dependent => :destroy
+end
+
+class InheritedParanoid < SuperParanoid
+  acts_as_paranoid
+end
+
+class ParanoidObserver < ActiveRecord::Observer
+  observe :paranoid_with_callback
+
+  attr_accessor :called_before_recover, :called_after_recover
+
+  def before_recover(paranoid_object)
+    self.called_before_recover = paranoid_object
+  end
+
+  def after_recover(paranoid_object)
+    self.called_after_recover = paranoid_object
+  end
+
+  def reset
+    self.called_before_recover = nil
+    self.called_after_recover = nil
+  end
+end
+
+ParanoidWithCallback.add_observer(ParanoidObserver.instance)

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: rails3_acts_as_paranoid_create
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Goncalo Silva
+- Philipp Ullmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  name: activerecord
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 9
+        - 0
+        version: 0.9.0
+  name: rake
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  name: sqlite3-ruby
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 3
+        - 1
+        - 0
+        version: 3.1.0
+  name: activesupport
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 3
+        - 9
+        - 0
+        version: 3.9.0
+  name: rdoc
+  version_requirements: *id005
+description: Active Record (>=3.0) plugin which allows you to hide and restore records without actually deleting them. Check its GitHub page for more in-depth information.
+email: 
+- goncalossilva@gmail.com
+- philipp.ullmann@create.at
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.markdown
+- Rakefile
+- init.rb
+- lib/rails3_acts_as_paranoid.rb
+- lib/rails3_acts_as_paranoid/version.rb
+- lib/validations/uniqueness_without_deleted.rb
+- rails3_acts_as_paranoid.gemspec
+- test/rails3_acts_as_paranoid_test.rb
+- test/test_helper.rb
+homepage: http://github.com/goncalossilva/rails3_acts_as_paranoid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: rails3_acts_as_paranoid_create
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Active Record (>=3.0) plugin which allows you to hide and restore records without actually deleting them.
+test_files: 
+- test/rails3_acts_as_paranoid_test.rb
+- test/test_helper.rb