rails3_acts_as_paranoid 0.2.0 → 0.2.1

data/README.markdown

@@ -14,103 +14,227 @@ While porting it to Rails 3, I decided to apply the ideas behind those plugins t
 
 You can enable ActsAsParanoid like this:
 
-    class Paranoiac < ActiveRecord::Base
-      acts_as_paranoid
-    end
+```ruby
+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'
+- `:column      => 'deleted_at'`
+- `:column_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".
+The values shown are the defaults. While *column* can be anything (as long as it exists in your database), *type* is restricted to:
 
-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").
+- `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
+```ruby
+Paranoiac.only_deleted # retrieves the deleted records
+Paranoiac.with_deleted # retrieves all records, deleted or not
+```
+
+When using the default `column_type` of `'time'`, the following extra scopes are provided:
+
+```ruby
+time = Time.now
+
+Paranoiac.deleted_after_time(time)
+Paranoiac.deleted_before_time(time)
+
+# Or roll it all up and get a nice window:
+Paranoiac.deleted_inside_time_window(time, 2.minutes)
+```
 
 ### Real deletion
 
 In order to really delete a record, just use:
 
-    paranoiac.destroy!
-    Paranoiac.delete_all!(conditions)
+```ruby
+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:
+You can also permanently 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
+```ruby
+p = Paranoiac.first
+p.destroy # does NOT delete the first record, just hides it
+Paranoiac.only_deleted.where(:id => p.id).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
+```ruby
+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)
+```ruby
+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
+If you would like to change this default behavior for one model, you can use the `recover_dependent_associations` option
 
-    class Paranoiac < ActiveRecord::Base
-        acts_as_paranoid :recover_dependent_associations => false
-    end
+```ruby
+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
+By default, dependent records will be recovered if they were deleted within 2 minutes 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.  The behavior is only available when both parent and dependant are using timestamp fields to mark deletion, which is the default behavior. This window can be changed with the `dependent_recovery_window` option:
 
-    class Paranoiac < ActiveRecord::Base
-        acts_as_paranoid
-        has_many :paranoids, :dependent => :destroy
-    end
+```ruby
+class Paranoiac < ActiveRecord::Base
+    acts_as_paranoid
+    has_many :paranoids, :dependent => :destroy
+end
 
-    class Paranoid < ActiveRecord::Base
-        belongs_to :paranoic
+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
+    # Paranoid objects will be recovered alongside Paranoic objects 
+    # if they were deleted within 10 minutes of the Paranoic object
+    acts_as_paranoid :dependent_recovery_window => 10.minutes
+end
+```
 
 or in the recover statement
 
-    Paranoiac.only_deleted.where("name = ?", "not dead yet").first.recover(:recovery_window => 30.seconds)
+```ruby
+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
+```ruby
+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
+p1 = Paranoiac.create(:name => 'foo')
+p1.destroy
     
+p2 = Paranoiac.new(:name => 'foo') 
+p2.valid? #=> true
+p2.save
+ 
+p1.recover #=> fails validation!
+```
 
 ### Status
-Once you retrieve data using `with_deleted` scope you can check deletion status using `deleted?` helper:
+You can check the status of your paranoid objects with the `deleted?` helper
 
-    Paranoiac.create(:name => 'foo').destroy
-    Paranoiac.with_deleted.first.deleted? #=> true
+```ruby
+Paranoiac.create(:name => 'foo').destroy
+Paranoiac.with_deleted.first.deleted? #=> true
+```
+    
+### Scopes
+
+As you've probably guessed, `with_deleted` and `only_deleted` are scopes. You can, however, chain them freely with other scopes you might have. This
+
+```ruby
+Paranoiac.pretty.with_deleted
+```
+
+is exactly the same as
+
+```ruby
+Paranoiac.with_deleted.pretty
+```
+
+You can work freely with scopes and it will just work:
+
+```ruby
+class Paranoiac < ActiveRecord::Base
+	acts_as_paranoid
+	scope :pretty, where(:pretty => true)
+end
+	
+Paranoiac.create(:pretty => true)
+	
+Paranoiac.pretty.count #=> 1
+Paranoiac.only_deleted.count #=> 0
+Paranoiac.pretty.only_deleted.count #=> 0
+	
+Paranoiac.first.destroy
+	
+Paranoiac.pretty.count #=> 0
+Paranoiac.only_deleted.count #=> 1
+Paranoiac.pretty.only_deleted.count #=> 1
+```
+
+### Associations
+
+Associations are also supported. From the simplest behaviors you'd expect to more nifty things like the ones mentioned previously or the usage of the `:with_deleted` option with `belongs_to`
+
+```ruby
+class ParanoiacParent < ActiveRecord::Base
+	has_many :children, :class_name => "ParanoiacChild"
+end
+	
+class ParanoiacChild < ActiveRecord::Base
+	belongs_to :parent, :class_name => "ParanoiacParent"
+	belongs_to :parent_with_deleted, :class_name => "ParanoiacParent", :with_deleted => true
+end
+	
+parent = ParanoiacParent.first 	
+child = parent.children.create
+parent.destroy
+     
+child.parent #=> nil
+child.parent_with_deleted #=> ParanoiacParent (it works!)
+```
 
 ## 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`
+-   You cannot use scopes named `with_deleted` and `only_deleted`
+-   You cannot use scopes named `deleted_inside_time_window`, `deleted_before_time`, `deleted_after_time` **if** your paranoid column's type is `time`
 -   `unscoped` will return all records, deleted or not
 
-## Acknowledgements
+# Support
+
+This gem supports the most recent versions of Rails and Ruby.
+
+## Rails
+
+For Rails 3.2 check the README at the [rails3.2](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.2) branch and add this to your Gemfile:
+	
+	gem "rails3_acts_as_paranoid", "~>0.2.0"
+	
+For Rails 3.1 check the README at the [rails3.1](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.1) branch and add this to your Gemfile:
+
+	gem "rails3_acts_as_paranoid", "~>0.1.4"
+
+For Rails 3.0 check the README at the [rails3.0](https://github.com/goncalossilva/rails3_acts_as_paranoid/tree/rails3.0) branch and add this to your Gemfile:
+
+	gem "rails3_acts_as_paranoid", "~>0.0.9"
+	
+	
+## Ruby
+
+This gem is tested on Ruby 1.9, JRuby and Rubinius (both in 1.9 mode). It *might* work fine in 1.8, but it's not officially supported.
+
+# Acknowledgements
 
 * To [cheerfulstoic](https://github.com/cheerfulstoic) for adding recursive recovery
 * To [Jonathan Vaught](https://github.com/gravelpup) for adding paranoid validations
@@ -118,5 +242,7 @@ Watch out for these caveats:
 * 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
+* To [Craig Walker](https://github.com/softcraft-development) for Rails 3.1 support and fixing various pending issues
+* To [Charles G.](https://github.com/chuckg) for Rails 3.2 support and for making a desperately needed global code refactoring
 
 Copyright © 2010 Gonçalo Silva, released under the MIT license

data/lib/acts_as_paranoid/associations.rb

@@ -0,0 +1,31 @@
+module ActsAsParanoid
+  module Associations
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class << self
+          alias_method_chain :belongs_to, :deleted
+        end
+      end
+    end
+
+    module ClassMethods
+      def belongs_to_with_deleted(target, options = {})
+        with_deleted = options.delete(:with_deleted)
+        result = belongs_to_without_deleted(target, options)
+      
+        if with_deleted
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{target}_with_unscoped(*args)
+              return #{target}_without_unscoped(*args) unless association(:#{target}).klass.paranoid?
+              association(:#{target}).klass.with_deleted.scoping { #{target}_without_unscoped(*args) }
+            end
+            alias_method_chain :#{target}, :unscoped
+          RUBY
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/acts_as_paranoid/core.rb

@@ -0,0 +1,157 @@
+module ActsAsParanoid
+  module Core
+    def self.included(base)
+      base.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
+        without_paranoid_default_scope
+      end
+
+      def only_deleted
+        without_paranoid_default_scope.where("#{paranoid_column_reference} IS NOT ?", nil)
+      end
+
+      def delete_all!(conditions = nil)
+        without_paranoid_default_scope.delete_all!(conditions)
+      end
+
+      def delete_all(conditions = nil)
+        update_all ["#{paranoid_configuration[:column]} = ?", delete_now_value], conditions
+      end
+
+      def paranoid_default_scope_sql
+        self.scoped.table[paranoid_column].eq(nil).to_sql
+      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
+
+    protected
+
+      def without_paranoid_default_scope
+        scope = self.scoped.with_default_scope
+        scope.where_values.delete(paranoid_default_scope_sql)
+
+        scope
+      end
+    end
+
+    def paranoid_value
+      self.send(self.class.paranoid_column)
+    end
+
+    def destroy!
+      with_transaction_returning_status do
+        run_callbacks :destroy do
+          destroy_dependent_associations!
+          self.class.delete_all!(self.class.primary_key.to_sym => 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(self.class.primary_key.to_sym => 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.paranoid_value = nil
+          self.save
+        end
+      end
+    end
+
+    def recover_dependent_associations(window, options)
+      self.class.dependent_associations.each do |reflection|
+        next unless reflection.klass.paranoid?
+
+        scope = reflection.klass.only_deleted
+        
+        # Merge in the association's scope
+        scope = scope.merge(association(reflection.name).association_scope)
+
+        # We can only recover by window if both parent and dependant have a
+        # paranoid column type of :time.
+        if self.class.paranoid_column_type == :time && reflection.klass.paranoid_column_type == :time
+          scope = scope.merge(reflection.klass.deleted_inside_time_window(paranoid_value, window))
+        end
+
+        scope.each do |object|
+          object.recover(options)
+        end
+      end
+    end
+    
+    def destroy_dependent_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.to_json})").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

data/lib/acts_as_paranoid/relation.rb

@@ -0,0 +1,37 @@
+module ActsAsParanoid
+  module Relation
+    def self.included(base)
+      base.class_eval do
+        
+        def paranoid?
+          klass.try(:paranoid?) ? true : false
+        end
+        
+        def paranoid_deletion_attributes
+          { klass.paranoid_column => klass.delete_now_value }
+        end
+
+        alias_method :orig_delete_all, :delete_all
+        def delete_all!(conditions = nil)
+          if conditions
+            where(conditions).delete_all!
+          else
+            orig_delete_all
+          end
+        end
+        
+        def delete_all(conditions = nil)
+          if paranoid?
+            update_all(paranoid_deletion_attributes, conditions)
+          else
+            delete_all!(conditions)
+          end
+        end
+
+        def destroy!(id_or_array)
+          where(primary_key => id_or_array).orig_delete_all
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_paranoid/validations.rb

@@ -0,0 +1,41 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActsAsParanoid
+  module Validations
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    class UniquenessWithoutDeletedValidator < ActiveRecord::Validations::UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table = finder_class.arel_table
+
+        coder = record.class.serialized_attributes[attribute.to_s]
+
+        if value && coder
+          value = coder.dump value
+        end
+
+        relation = build_relation(finder_class, table, attribute, value)
+        relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.send(:id))) if record.persisted?
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.and(table[scope_item].eq(scope_value))
+        end
+
+        # Re-add ActsAsParanoid default scope conditions manually. 
+        if finder_class.unscoped.where(finder_class.paranoid_default_scope_sql).where(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
+end

data/lib/rails3_acts_as_paranoid.rb

@@ -1,66 +1,20 @@
-require 'active_record'
-require 'validations/uniqueness_without_deleted'
+require 'active_record/base'
+require 'active_record/relation'
+require 'active_record/callbacks'
+require 'acts_as_paranoid/core'
+require 'acts_as_paranoid/associations'
+require 'acts_as_paranoid/validations'
+require 'acts_as_paranoid/relation'
 
 
-module ActiveRecord
-  class Relation
-    def paranoid?
-      klass.try(:paranoid?) ? true : false
-    end
-    
-    def paranoid_deletion_attributes
-      { klass.paranoid_column => klass.delete_now_value }
-    end
-    
-    alias_method :destroy!, :destroy
-    def destroy(id)
-      if paranoid?
-        update_all(paranoid_deletion_attributes, {:id => id})
-      else
-        destroy!(id)
-      end
-    end
-    
-    alias_method :really_delete_all!, :delete_all
-    
-    def delete_all!(conditions = nil)
-      if conditions
-        # This idea comes out of Rails 3.1 ActiveRecord::Record.delete_all
-        where(conditions).delete_all!
-      else
-        really_delete_all!
-      end
-    end
-    
-    def delete_all(conditions = nil)
-      if paranoid?
-        update_all(paranoid_deletion_attributes, conditions)
-      else
-        delete_all!(conditions)
-      end
-    end
-    
-    def arel=(a)
-      @arel = a
-    end
-    
-    def with_deleted
-      wd = self.clone
-      wd.default_scoped = false
-      wd.arel = self.build_arel
-      wd
-    end
-  end
-end
-
 module ActsAsParanoid
   
   def paranoid?
-    self.included_modules.include?(InstanceMethods)
+    self.included_modules.include?(ActsAsParanoid::Core)
   end
   
   def validates_as_paranoid
-    extend ParanoidValidations::ClassMethods
+    include ActsAsParanoid::Validations
   end
   
   def acts_as_paranoid(options = {})
@@ -78,203 +32,28 @@ module ActsAsParanoid
     
     return if paranoid?
     
-    # Magic!
-    default_scope 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 deletion_conditions(id_or_array)
-      ["id in (?)", [id_or_array].flatten]
-    end
-    
-    def delete!(id_or_array)
-      delete_all!(deletion_conditions(id_or_array))
-    end
-    
-    def delete(id_or_array)
-      delete_all(deletion_conditions(id_or_array))
-    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
+    include ActsAsParanoid::Core
+    include ActsAsParanoid::Associations
     
-    def destroy!
-      with_transaction_returning_status do
-        run_callbacks :destroy do
-          act_on_dependent_destroy_associations
-          self.class.delete_all!(self.class.primary_key.to_sym => 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(self.class.primary_key.to_sym => self.id)
-            self.paranoid_value = self.class.delete_now_value
-            self
-          end
-        end
-      else
-        destroy!
-      end
-    end
-    
-    def delete!
-      with_transaction_returning_status do
-        act_on_dependent_destroy_associations
-        self.class.delete_all!(self.class.primary_key.to_sym => self.id)
-        self.paranoid_value = self.class.delete_now_value
-        freeze
-      end
-    end
-    
-    def delete
-      if paranoid_value.nil?
-        with_transaction_returning_status do
-          self.class.delete_all(self.class.primary_key.to_sym => self.id)
-          self.paranoid_value = self.class.delete_now_value
-          self
-        end
-      else
-        delete!
-      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.paranoid_value = nil
-          self.save
-        end
-      end
-    end
+    # Magic!
+    default_scope { where(paranoid_default_scope_sql) }
 
-    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.to_json})").each do |object|
-            object.destroy!
-          end
-        end
-      end
-    end
+    if paranoid_configuration[:column_type] == 'time'
+      scope :deleted_inside_time_window, lambda {|time, window|
+        deleted_after_time((time - window)).deleted_before_time((time + window))
+      }
 
-    def deleted?
-      !paranoid_value.nil?
-    end
-    alias_method :destroyed?, :deleted?
-    
-  private
-    def paranoid_value=(value)
-      self.send("#{self.class.paranoid_column}=", value)
+      scope :deleted_after_time, lambda  { |time| where("#{paranoid_column} > ?", time) }
+      scope :deleted_before_time, lambda { |time| where("#{paranoid_column} < ?", time) }
     end
-    
   end
-  
 end
 
-
 # Extend ActiveRecord's functionality
 ActiveRecord::Base.send :extend, ActsAsParanoid
 
+# Override ActiveRecord::Relation's behavior
+ActiveRecord::Relation.send :include, ActsAsParanoid::Relation
+
 # Push the recover callback onto the activerecord callback list
 ActiveRecord::Callbacks::CALLBACKS.push(:before_recover, :after_recover)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails3_acts_as_paranoid
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000Z
+date: 2012-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70311543517160 !ruby/object:Gem::Requirement
+  requirement: &70201325143880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '3.2'
   type: :runtime
   prerelease: false
-  version_requirements: *70311543517160
+  version_requirements: *70201325143880
 description: Active Record (~>3.2) plugin which allows you to hide and restore records
   without actually deleting them. Check its GitHub page for more in-depth information.
 email:
@@ -30,11 +30,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/acts_as_paranoid/associations.rb
+- lib/acts_as_paranoid/core.rb
+- lib/acts_as_paranoid/relation.rb
+- lib/acts_as_paranoid/validations.rb
 - lib/rails3_acts_as_paranoid.rb
-- lib/validations/uniqueness_without_deleted.rb
 - LICENSE
 - README.markdown
-homepage: https://github.com/softcraft-development/rails3_acts_as_paranoid
+homepage: https://github.com/goncalossilva/rails3_acts_as_paranoid
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -48,7 +51,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1615322302278310940
+      hash: -2548769094078379763
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -57,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: rails3_acts_as_paranoid
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Active Record (~>3.2) plugin which allows you to hide and restore records

data/lib/validations/uniqueness_without_deleted.rb

@@ -1,39 +0,0 @@
-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
-
-      table = Arel::Table.new(record.class.table_name)
-      sql, params = build_relation(finder_class, table, 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