phurni-is_less_paranoid 0.9.0

data/IS_PARANOID_CHANGELOG

@@ -0,0 +1,31 @@
+This will only document major changes.  Please see the commit log for minor changes.
+
+-2009-06-13
+* added support for is_paranoid conditions being maintained on preloaded associations
+* destroy and restore now return self (to be more in keeping with other ActiveRecord methods) via Brent Dillingham
+
+-2009-05-19
+* added support for specifying relationships to restore via instance_model.restore(:include => [:parent_1, :child_1, :child_2]), etc.
+* method_missing is no longer overridden on instances provided you declare your custom method_missing *before* specifying the model is_paranoid
+
+-2009-05-12
+* added support for parent_with_destroyed methods
+
+-2009-04-27
+* restoring models now cascades to child dependent => destroy models via Matt Todd
+
+-2009-04-22
+* destroying and restoring records no longer triggers saving/updating callbacks
+
+-2009-03-28
+* removing syntax for calculation require (all find and ActiveRecord calculations are done on-the-fly now via method_missing)
+* adding ability to specify alternate fields and values for destroyed objects
+* adding in support for _destroyed_only methods (with inspiration from David Krmpotic)
+* adding init.rb via David Krmpotic
+* adding jewler tasks via Scott Woods
+
+-2009-03-24
+* requiring specific syntax to include calculations
+
+-2009-03-21
+* initial release

data/IS_PARANOID_README.textile

@@ -0,0 +1,103 @@
+h1. is_paranoid ( same as it ever was )
+
+h3. and you may ask yourself, well, how did I get here?
+
+Sometimes you want to delete something in ActiveRecord, but you realize you might need it later (for an undo feature, or just as a safety net, etc.).  There are a plethora of plugins that accomplish this, the most famous of which is the venerable acts_as_paranoid which is great but not really actively developed any more.  What's more, acts_as_paranoid was written for an older version of ActiveRecord and, with default_scope in 2.3, it is now possible to do the same thing with significantly less complexity.  Thus, *is_paranoid*.
+
+h3. and you may ask yourself, how do I work this?
+
+You should read the specs, or the RDOC, or even the source itself (which is very readable), but for the lazy, here's the hand-holding:
+
+You need ActiveRecord 2.3 and you need to properly install this gem.  Then you need a model with a field to serve as a flag column on its database table.  For this example we'll use a timestamp named "deleted_at".  If that column is null, the item isn't deleted.  If it has a timestamp, it should count as deleted.
+
+So let's assume we have a model Automobile that has a deleted_at column on the automobiles table.
+
+If you're working with Rails, in your environment.rb, add the following to your initializer block (you may want to change the version number).
+
+<pre>
+Rails::Initializer.run do |config|
+  # ...
+  config.gem "jchupp-is_paranoid", :lib => 'is_paranoid', :version => ">= 0.0.1"
+end
+</pre>
+
+Then in your ActiveRecord model
+
+<pre>
+class Automobile < ActiveRecord::Base
+  is_paranoid
+end
+</pre>
+
+Now our automobiles are now soft-deleteable.
+
+<pre>
+  that_large_automobile = Automobile.create()
+  Automobile.count # => 1
+
+  that_large_automobile.destroy
+  Automobile.count # => 0
+  Automobile.count_with_destroyed # => 1
+
+  # where is that large automobile?
+  that_large_automobile = Automobile.find_with_destroyed(:all).first
+  that_large_automobile.restore
+  Automobile.count # => 1
+</pre>
+
+One thing to note, destroying is always undo-able, but deleting is not.  This is a behavior difference between acts_as_paranoid and is_paranoid.
+
+<pre>
+  Automobile.destroy_all
+  Automobile.count # => 0
+  Automobile.count_with_destroyed # => 1
+  
+  Automobile.delete_all
+  Automobile.count_with_destroyed # => 0
+  # And you may say to yourself, "My god!  What have I done?"
+</pre>
+
+All calculations and finds are created via a define_method call in method_missing.  So you don't get a bunch of unnecessary methods defined unless you use them.  Any find/count/sum/etc. _with_destroyed calls should work and you can also do find/count/sum/etc._destroyed_only.
+
+h3. Specifying alternate rules for what should be considered destroyed
+
+"deleted_at" as a timestamp is what acts_as_paranoid uses to define what is and isn't destroyed (see above), but you can specify alternate options with is_paranoid.  In the is_paranoid line of your model you can specify the field, the value the field should have if the entry should count as destroyed, and the value the field should have if the entry is not destroyed.  Consider the following models:
+
+<pre>
+  class Pirate < ActiveRecord::Base
+    is_paranoid :field => [:alive, false, true]
+  end
+
+  class DeadPirate < ActiveRecord::Base
+    set_table_name :pirates
+    is_paranoid :field => [:alive, true, false]
+  end
+</pre>
+
+These two models share the same table, but when we are finding Pirates, we're only interested in those that are alive.  To break it down, we specify :alive as our field to check, false as what the model field should be marked at when destroyed and true to what the field should be if they're not destroyed.  DeadPirates are specified as the opposite.  Check out the specs if you're still confused.
+
+h3. Note about validates_uniqueness_of:
+
+validates_uniqueness_of does not, by default, ignore items marked with a deleted_at (or other field name) flag.  This is a behavior difference between is_paranoid and acts_as_paranoid.  You can overcome this by specifying the field name you are using to mark destroyed items as your scope.  Example:
+
+<pre>
+  class Android < ActiveRecord::Base
+    validates_uniqueness_of :name, :scope => :deleted_at
+    is_paranoid
+  end
+</pre>
+
+And now the validates_uniqueness_of will ignore items that are destroyed.
+
+h3. and you may ask yourself, where does that highway go to?
+
+If you find any bugs, have any ideas of features you think are missing, or find things you're like to see work differently, feel free to send me a message or a pull request.
+
+Currently on the todo list:
+* add options for merging additional default_scope options (i.e. order, etc.)
+
+h3. Thanks
+
+Thanks to Rick Olson for acts_as_paranoid which is obviously an inspiration in concept and execution, Ryan Bates for mentioning the idea of using default_scope for this on Ryan Daigle's "post introducing default_scope":defscope, and the Talking Heads for being the Talking Heads. 
+
+[defscope]http://ryandaigle.com/articles/2008/11/18/what-s-new-in-edge-rails-default-scoping

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Jeffrey Chupp
+
+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.textile

@@ -0,0 +1,220 @@
+h1. is_less_paranoid
+
+This plugin is a fork of the original project "is_paranoid":http://github.com/semanticart/is_paranoid/tree .
+
+Please "refer to it":http://github.com/phurni/is_less_paranoid/tree/master/IS_PARANOID_README.textile for the basic what it is.
+
+
+h3. Less is More
+
+Let's take an example to show the added behaviour of the *is_less_paranoid* plugin.
+
+Say you have _projects_, _tasks_ and _workers_. A task belongs to a project and is executed by a worker.
+As in the real life, projects may be canceled. So we delete a project (the Project model has been 'paranoid').
+Now when we want to list all tasks made by a worker, the ones that concerned the deleted project will contain
+a _nil_ association for the project.
+
+<pre>
+  class Project < ActiveRecord::Base
+    has_many :tasks
+  
+    is_paranoid
+  end
+
+  class Worker < ActiveRecord::Base
+    has_many :tasks
+  
+    is_paranoid
+  end
+
+  class Task < ActiveRecord::Base
+    belongs_to :project
+    belongs_to :worker
+    
+    is_paranoid
+  end
+</pre>
+
+<pre>
+  house = Project.create(:name => 'Build a house')
+  joe = Worker.create(:name => 'Joe')
+  Task.create(:name => 'paint walls', :worker => joe, :project => house)
+  
+  house.destroy
+  the_task = joe.tasks.first
+  the_task.name      # <== returns 'paint walls'
+  the_task.project   # <== returns nil
+</pre>
+
+In this scenario I would prefer to see the associated but deleted project. I could even show the destroyed state
+in the view with a specific style.
+
+This is exactly the aim of *is_less_paranoid*
+
+Note though that when I want to assign a project to a new task I want to list only the undestroyed projects.
+This is done with this:
+
+<pre>
+  projects = ProjectAlive.all
+</pre>
+
+Hey, I didn't setup a ProjectAlive model! Yes, *is_less_paranoid* did it.
+
+
+h3. How to use it
+
+When you add *is_less_paranoid* to your model it will modify it to handle soft deletion (exactly what is_paranoid does)
+but it won't scope your finds with the deleted flag. So any AR find will find normal records and deleted records.
+
+This is the reason why associated records are still found even when destroyed.
+
+Now when you want to scope your finds with the deleted flag, simply use another model named
+YourModel<strong>Alive</strong> which is automatically created by is_less_paranoid and has exactly the same
+behaviour of your original model (except the scoping).
+
+<pre>
+  class Project < ActiveRecord::Base
+    has_many :tasks
+  
+    is_less_paranoid
+  end
+
+  class Worker < ActiveRecord::Base
+    has_many :tasks
+  
+    is_less_paranoid
+  end
+
+  class Task < ActiveRecord::Base
+    belongs_to :project
+    belongs_to :worker
+    
+    is_less_paranoid
+  end
+</pre>
+
+<pre>
+  house = Project.create(:name => 'Build a house')
+  joe = Worker.create(:name => 'Joe')
+  Task.create(:name => 'paint walls', :worker => joe, :project => house)
+  
+  house.destroy
+  the_task = joe.tasks.first
+  the_task.name      # => 'paint walls'
+  the_task.project   # => Project(name:Build a house)
+  
+  ProjectAlive.all   # => []
+  Project.all        # => [Project(name:Build a house)]
+</pre>
+
+h4. I want my association to behave like is_paranoid
+
+This is why you have a cloned model, simply tell that class name in your association
+
+<pre>
+  class Project < ActiveRecord::Base
+    has_many :tasks, :class_name => 'TaskAlive'
+  
+  end
+
+  class Task < ActiveRecord::Base
+    belongs_to :project
+    belongs_to :worker
+    
+    is_less_paranoid
+  end
+</pre>
+
+<pre>
+  house = Project.create(:name => 'Build a house')
+  painting = Task.create(:name => 'paint walls', :project => house)
+  Task.create(:name => 'clean roof', :project => house)
+  house.tasks  # => [Task(name:paint walls), Task(name:clean roof)]
+  painting.destroy
+  house.tasks  # => [Task(name:clean roof)]
+</pre>
+
+h4. I want my model to scope finds and the clone class not to
+
+Yes sometimes the 'Alive' model should be your real model, which is exactly the opposite way of the default
+behaviour for the clone class.
+
+No problem, tell it with the option :clone => :with_destroyed. This will create a clone class with 'WithDestroyed'
+as a suffix.
+
+<pre>
+  class Worker < ActiveRecord::Base
+    has_many :tasks
+  
+    is_less_paranoid :clone => :with_destroyed
+  end
+</pre>
+
+<pre>
+  joe = Worker.create(:name => 'Joe')
+  Worker.all                # => [Worker(name:Joe)]
+  WorkerWithDestroyed.all   # => [Worker(name:Joe)]
+  
+  joe.destroy
+  Worker.all                # => []
+  WorkerWithDestroyed.all   # => [Worker(name:Joe)]
+</pre>
+
+Hey, 'WithDestroyed' is ugly. Okay, so choose your prefix or suffix by adding an option
+
+<pre>
+  class Worker < ActiveRecord::Base
+    has_many :tasks
+  
+    is_less_paranoid :clone => :with_destroyed, :suffix => 'WithFired'
+  end
+</pre>
+
+<pre>
+  joe = Worker.create(:name => 'Joe')
+  Worker.all                # => [Worker(name:Joe)]
+  WorkerWithFired.all       # => [Worker(name:Joe)]
+  
+  joe.destroy
+  Worker.all                # => []
+  WorkerWithFired.all       # => [Worker(name:Joe)]
+</pre>
+
+h4. I want bare bone is_paranoid behaviour
+
+And you don't want to install the is_paranoid gem, then simply tell that you don't want a clone class
+with the option :clone => false.
+
+<pre>
+  class Project < ActiveRecord::Base
+    has_many :tasks
+  
+    is_less_paranoid :clone => false
+  end
+</pre>
+
+
+h3. Installation
+
+You need ActiveRecord 2.3 and you need to properly install this gem.
+
+If you're working with Rails, in your environment.rb, add the following to your initializer block.
+
+<pre>
+Rails::Initializer.run do |config|
+  # ...
+  config.gem "phurni-is_less_paranoid", :lib => 'is_less_paranoid'
+end
+</pre>
+
+
+h3. is_paranoid
+
+Every option of the is_paranoid plugin should work with *is_less_paranoid*.
+
+Please let me know if you find issues specific to *is_less_paranoid*.
+
+h3. Thanks
+
+Thanks to *Jeffrey Chupp* for the rewamped acts_as_paranoid aka *is_paranoid*.
+

data/Rakefile

@@ -0,0 +1,24 @@
+require "spec"
+require "spec/rake/spectask"
+require 'lib/is_less_paranoid.rb'
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = %q{is_less_paranoid}
+    s.summary = %q{ActiveRecord 2.3 compatible gem "allowing you to hide and restore records without actually deleting them."  Yes, like acts_as_paranoid, only with less code and less complexity. Extended version to allow associated records to still be alive.}
+    s.email = %q{pascal_hurni@fastmail.fm}
+    s.homepage = %q{http://github.com/phurni/is_less_paranoid/}
+    s.description = ""
+    s.authors = ["Pascal Hurni", "Jeffrey Chupp"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :default  => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 9
+:patch: 0
+:major: 0

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails/init')

data/lib/is_less_paranoid.rb

@@ -0,0 +1,304 @@
+require 'activerecord'
+
+module IsLessParanoid
+  # Call this in your model to enable all the safety-net goodness
+  #
+  # Example:
+  #
+  # class Android < ActiveRecord::Base
+  #   is_less_paranoid
+  # end
+  #
+
+  def is_less_paranoid opts = {}
+    opts[:field] ||= [:deleted_at, Proc.new{Time.now.utc}, nil]
+    class_inheritable_accessor :destroyed_field, :field_destroyed, :field_not_destroyed
+    self.destroyed_field, self.field_destroyed, self.field_not_destroyed = opts[:field]
+
+    extend ClassMethods
+    include InstanceMethods
+    
+    # :clone => :with_destroyed # :clone => :alive # :clone => false
+    default_options = {:suffix => opts[:prefix] ? nil : ((opts[:clone] == :with_destroyed) ? 'WithDestroyed' : 'Alive'), :clone => :alive}
+    clone_class_and_apply_constraints(opts.reverse_merge(default_options))
+  end
+
+  module CloneClassMethods
+    def paranoid_original_class
+      @paranoid_original_class
+    end
+  
+    def sti_name
+      @paranoid_original_class.sti_name
+    end
+  
+    def descends_from_active_record?
+      @paranoid_original_class.descends_from_active_record?
+    end
+  end
+
+  module ClassMethods
+    def inherited(subclass) # :nodoc:
+      super
+      subclass.clone_class_and_apply_constraints(@paranoid_options) unless @cloning || (@paranoid_original_class !=self)
+    end
+  
+    def clone_class_and_apply_constraints(options) # :nodoc:
+      @paranoid_options = options
+      @paranoid_options[:scope_destroyed] = case options[:clone]
+        when :with_destroyed then true
+        when :alive then false
+        when false then true
+        else
+          raise ArgumentError, "Unknown value #{options[:clone]} for option :clone"
+      end
+      
+      if options[:clone]
+        table_name  # force naming the table (works even if set_table_name has been called)
+
+        # Create a cloned class in the same namespace with the supplied prefix and suffix
+        nesting = self.name.split("::")
+        original_class_name = nesting.pop
+        clone_class_name = "#{options[:prefix]}#{original_class_name}#{options[:suffix]}"
+        namespace = "::#{nesting.join("::")}".constantize
+        @cloning = true # FIXME: Not thread safe, should use a Mutex
+        namespace.module_eval "class #{clone_class_name} < #{original_class_name}; end"
+        @cloning = false
+        clone_class = namespace.const_get(clone_class_name)
+        
+        @paranoid_original_class = self
+        clone_class.instance_variable_set(:@paranoid_original_class, self)
+        clone_class.instance_variable_set(:@paranoid_options, @paranoid_options.reverse_merge(:scope_destroyed => (options[:clone] == :alive)))
+
+        clone_class.extend CloneClassMethods
+      end
+      
+      klass = (options[:clone] == :alive) ? clone_class : self
+      
+      # This is the real magic. All calls made to this model will append
+      # the conditions deleted_at => nil (or whatever your destroyed_field
+      # and field_not_destroyed are). All exceptions require using
+      # exclusive_scope (see self.delete_all, self.count_with_destroyed,
+      # and self.find_with_destroyed defined in the module ClassMethods)
+      klass.send(:default_scope, :conditions => {destroyed_field => field_not_destroyed})
+    end
+    protected :inherited, :clone_class_and_apply_constraints
+    
+    def paranoid_original_class
+      self
+    end
+  
+    # Actually delete the model, bypassing the safety net. Because
+    # this method is called internally by Model.delete(id) and on the
+    # delete method in each instance, we don't need to specify those
+    # methods separately
+    def delete_all conditions = nil
+      self.with_exclusive_scope { super conditions }
+    end
+
+    # Use update_all with an exclusive scope to restore undo the soft-delete.
+    # This bypasses update-related callbacks.
+    #
+    # By default, restores cascade through associations that are belongs_to
+    # :dependent => :destroy and under is_paranoid. You can prevent restoration
+    # of associated models by passing :include_destroyed_dependents => false,
+    # for example:
+    #
+    #   Android.restore(:include_destroyed_dependents => false)
+    #
+    # Alternatively you can specify which relationships to restore via :include,
+    # for example:
+    #
+    #  Android.restore(:include => [:parts, memories])
+    #
+    # Please note that specifying :include means you're not using
+    # :include_destroyed_dependents by default, though you can explicitly use
+    # both if you want all has_* relationships and specific belongs_to
+    # relationships, for example
+    #
+    #  Android.restore(:include => [:home, :planet], :include_destroyed_dependents => true)
+    def restore(id, options = {})
+      options.reverse_merge!({:include_destroyed_dependents => true}) unless options[:include]
+      with_exclusive_scope do
+        update_all(
+        "#{destroyed_field} = #{connection.quote(field_not_destroyed)}",
+        "id = #{id}"
+        )
+      end
+
+      self.reflect_on_all_associations.each do |association|
+        if association.options[:dependent] == :destroy and association.klass.respond_to?(:restore)
+          dependent_relationship = association.macro.to_s =~ /^has/
+          if should_restore?(association.name, dependent_relationship, options)
+            if dependent_relationship
+              restore_related(association.klass, association.primary_key_name, id, options)
+            else
+              restore_related(
+                association.klass,
+                association.klass.primary_key,
+                self.first(id).send(association.primary_key_name),
+                options
+              )
+            end
+          end
+        end
+      end
+    end
+
+    # find_with_destroyed and other blah_with_destroyed and
+    # blah_destroyed_only methods are defined here
+    def method_missing name, *args, &block
+      if name.to_s =~ /^(.*)(_destroyed_only|_with_destroyed)$/ and self.respond_to?($1)
+        self.extend(Module.new{
+          if $2 == '_with_destroyed'
+            # Example:
+            # def count_with_destroyed(*args)
+            #   self.with_exclusive_scope{ self.send(:count, *args) }
+            # end
+            define_method name do |*args|
+              self.with_exclusive_scope{ self.send($1, *args) }
+            end
+          else
+
+            # Example:
+            # def count_destroyed_only(*args)
+            #   self.with_exclusive_scope do
+            #     with_scope({:find => { :conditions => ["#{destroyed_field} IS NOT ?", nil] }}) do
+            #       self.send(:count, *args)
+            #     end
+            #   end
+            # end
+            define_method name do |*args|
+              self.with_exclusive_scope do
+                with_scope({:find => { :conditions => ["#{self.table_name}.#{destroyed_field} IS NOT ?", field_not_destroyed] }}) do
+                  self.send($1, *args, &block)
+                end
+              end
+            end
+
+          end
+        })
+      self.send(name, *args, &block)
+      else
+        super(name, *args, &block)
+      end
+    end
+
+    # with_exclusive_scope is used internally by ActiveRecord when preloading
+    # associations.  Unfortunately this is problematic for is_paranoid since we
+    # want preloaded is_paranoid items to still be scoped to their deleted conditions.
+    # so we override that here.
+    def with_exclusive_scope(method_scoping = {}, &block)
+      # this is rather hacky, suggestions for improvements appreciated... the idea
+      # is that when the caller includes the method preload_associations, we want
+      # to apply our is_paranoid conditions
+      if @paranoid_options[:scope_destroyed]
+        if caller.any?{|c| c =~ /\d+:in `preload_associations'$/}
+          method_scoping.deep_merge!(:find => {:conditions => {destroyed_field => field_not_destroyed} })
+        end
+      end
+      super method_scoping, &block
+    end
+
+    protected
+
+    def should_restore?(association_name, dependent_relationship, options) #:nodoc:
+      ([*options[:include]] || []).include?(association_name) or
+        (options[:include_destroyed_dependents] and dependent_relationship)
+    end
+
+    def restore_related klass, key_name, id, options #:nodoc:
+      klass.find_destroyed_only(:all,
+        :conditions => ["#{key_name} = ?", id]
+      ).each do |model|
+        model.restore(options)
+      end
+    end
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      base.class_eval do
+        unless method_defined? :method_missing
+          def method_missing(meth, *args, &block); super; end
+        end
+        alias_method :old_method_missing, :method_missing
+        alias_method :method_missing, :is_paranoid_method_missing
+      end
+    end
+
+    def is_paranoid_method_missing name, *args, &block
+      # if we're trying for a _____with_destroyed method
+      # and we can respond to the _____ method
+      # and we have an association by the name of _____
+      if name.to_s =~ /^(.*)(_with_destroyed)$/ and
+          self.respond_to?($1) and
+          (assoc = self.class.reflect_on_all_associations.detect{|a| a.name.to_s == $1})
+
+        parent_klass = Object.module_eval("::#{assoc.class_name}", __FILE__, __LINE__)
+
+        self.class.send(
+          :include,
+          Module.new{                                 # Example:
+            define_method name do |*args|             # def android_with_destroyed
+              parent_klass.first_with_destroyed(      #   Android.first_with_destroyed(
+                :conditions => {                      #     :conditions => {
+                  parent_klass.primary_key =>         #       :id =>
+                    self.send(assoc.primary_key_name) #         self.send(:android_id)
+                }                                     #     }
+              )                                       #   )
+            end                                       # end
+          }
+        )
+        self.send(name, *args, &block)
+      else
+        old_method_missing(name, *args, &block)
+      end
+    end
+
+    # Mark the model deleted_at as now.
+    def destroy_without_callbacks
+      self.class.update_all(
+        "#{destroyed_field} = #{self.class.connection.quote(( field_destroyed.respond_to?(:call) ? field_destroyed.call : field_destroyed))}",
+        "id = #{self.id}"
+      )
+      self
+    end
+
+    # Override the default destroy to allow us to flag deleted_at.
+    # This preserves the before_destroy and after_destroy callbacks.
+    # Because this is also called internally by Model.destroy_all and
+    # the Model.destroy(id), we don't need to specify those methods
+    # separately.
+    def destroy
+      return false if callback(:before_destroy) == false
+      result = destroy_without_callbacks
+      callback(:after_destroy)
+      self
+    end
+
+    # Set deleted_at flag on a model to field_not_destroyed, effectively
+    # undoing the soft-deletion.
+    def restore(options = {})
+      self.class.restore(id, options)
+      self
+    end
+
+    # Checks whenever this record is destroyed
+    # (so that returned records from find with destroyed may be checked against their state)
+    def destroyed?
+      send(self.class.destroyed_field) != self.class.field_not_destroyed
+    end
+
+    # Records of the original class and the clone class must match
+    def ==(comparison_object)
+      super ||
+        ((self.class.paranoid_original_class == (comparison_object.class.paranoid_original_class rescue nil)) &&
+          comparison_object.id == id &&
+          !comparison_object.new_record?)
+    end
+  end
+
+end
+
+ActiveRecord::Base.send(:extend, IsLessParanoid)