amiel-is_paranoid 0.9.2

data/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 "semanticart-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/Rakefile

@@ -0,0 +1,24 @@
+require "spec"
+require "spec/rake/spectask"
+require 'lib/is_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_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.}
+    s.email = %q{jeff@semanticart.com}
+    s.homepage = %q{http://github.com/jchupp/is_paranoid/}
+    s.description = ""
+    s.authors = ["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: 2
+:major: 0

data/lib/is_paranoid.rb

@@ -0,0 +1,243 @@
+require 'activerecord'
+
+module IsParanoid
+  # Call this in your model to enable all the safety-net goodness
+  #
+  # Example:
+  #
+  # class Android < ActiveRecord::Base
+  #   is_paranoid
+  # end
+  #
+
+  def is_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]
+
+    # 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)
+    default_scope :conditions => {destroyed_field => field_not_destroyed}
+
+    extend ClassMethods
+    include InstanceMethods
+  end
+
+  module ClassMethods
+    # 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 caller.any?{|c| c =~ /\d+:in `preload_associations'$/}
+        method_scoping.deep_merge!(:find => {:conditions => {destroyed_field => field_not_destroyed} })
+      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 {
+						if assoc.macro.to_s =~ /^has/
+							parent_method = assoc.macro.to_s =~ /^has_one/ ? 'first_with_destroyed' : 'all_with_destroyed'
+							                                            # Example:
+	            define_method name do |*args|               # def android_with_destroyed
+	              parent_klass.send("#{parent_method}",     #   Android.all_with_destroyed(
+	                :conditions => {                        #     :conditions => {
+	                  assoc.primary_key_name =>             #       :person_id =>
+	                    self.send(parent_klass.primary_key) #         self.send(:id)
+	                }                                       #     }
+	              )                                         #   )
+	            end                                         # end
+	
+						else
+                                                          # 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
+						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
+
+  end
+
+end
+
+ActiveRecord::Base.send(:extend, IsParanoid)

data/spec/database.yml

@@ -0,0 +1,3 @@
+test:
+  :adapter: sqlite3
+  :database: is_paranoid.db

data/spec/is_paranoid_spec.rb

@@ -0,0 +1,284 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/models')
+
+LUKE = 'Luke Skywalker'
+
+describe IsParanoid do
+  before(:each) do
+    Android.delete_all
+    Person.delete_all
+    Component.delete_all
+
+    @luke = Person.create(:name => LUKE)
+    @r2d2 = Android.create(:name => 'R2D2', :owner_id => @luke.id)
+    @c3p0 = Android.create(:name => 'C3P0', :owner_id => @luke.id)
+
+    @r2d2.components.create(:name => 'Rotors')
+
+    @r2d2.memories.create(:name => 'A pretty sunset')
+    @c3p0.sticker = Sticker.create(:name => 'OMG, PONIES!')
+  end
+
+  describe 'non-is_paranoid models' do
+    it "should destroy as normal" do
+      lambda{
+        @luke.destroy
+      }.should change(Person, :count).by(-1)
+
+      lambda{
+        Person.count_with_destroyed
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe 'destroying' do
+    it "should soft-delete a record" do
+       lambda{
+         Android.destroy(@r2d2.id)
+       }.should change(Android, :count).from(2).to(1)
+       Android.count_with_destroyed.should == 2
+    end
+
+    it "should not hit update/save related callbacks" do
+      lambda{
+        Android.first.update_attribute(:name, 'Robocop')
+      }.should raise_error
+
+      lambda{
+        Android.first.destroy
+      }.should_not raise_error
+    end
+
+    it "should soft-delete matching items on Model.destroy_all" do
+      lambda{
+        Android.destroy_all("owner_id = #{@luke.id}")
+      }.should change(Android, :count).from(2).to(0)
+      Android.count_with_destroyed.should == 2
+    end
+
+    describe 'related models' do
+      it "should no longer show up in the relationship to the owner" do
+        @luke.androids.size.should == 2
+        @r2d2.destroy
+        @luke.androids.size.should == 1
+      end
+
+      it "should soft-delete on dependent destroys" do
+        lambda{
+          @luke.destroy
+        }.should change(Android, :count).from(2).to(0)
+        Android.count_with_destroyed.should == 2
+      end
+    end
+  end
+
+  describe 'finding destroyed models' do
+    it "should be able to find destroyed items via #find_with_destroyed" do
+      @r2d2.destroy
+      Android.find(:first, :conditions => {:name => 'R2D2'}).should be_blank
+      Android.first_with_destroyed(:conditions => {:name => 'R2D2'}).should_not be_blank
+    end
+
+    it "should be able to find only destroyed items via #find_destroyed_only" do
+      @r2d2.destroy
+      Android.all_destroyed_only.size.should == 1
+      Android.first_destroyed_only.should == @r2d2
+    end
+
+    it "should not show destroyed models via :include" do
+      Person.first(:conditions => {:name => LUKE}, :include => :androids).androids.size.should == 2
+      @r2d2.destroy
+      person = Person.first(:conditions => {:name => LUKE}, :include => :androids)
+      # ensure that we're using the preload and not loading it via a find
+      Android.should_not_receive(:find)
+      person.androids.size.should == 1
+    end
+  end
+
+  describe 'calculations' do
+    it "should have a proper count inclusively and exclusively of destroyed items" do
+      @r2d2.destroy
+      @c3p0.destroy
+      Android.count.should == 0
+      Android.count_with_destroyed.should == 2
+    end
+
+    it "should respond to various calculations" do
+      @r2d2.destroy
+      Android.sum('id').should == @c3p0.id
+      Android.sum_with_destroyed('id').should == @r2d2.id + @c3p0.id
+      Android.average_with_destroyed('id').should == (@r2d2.id + @c3p0.id) / 2.0
+    end
+  end
+
+  describe 'deletion' do
+    it "should actually remove records on #delete_all" do
+      lambda{
+        Android.delete_all
+      }.should change(Android, :count_with_destroyed).from(2).to(0)
+    end
+
+    it "should actually remove records on #delete" do
+      lambda{
+        Android.first.delete
+      }.should change(Android, :count_with_destroyed).from(2).to(1)
+    end
+  end
+
+  describe 'restore' do
+    it "should allow restoring soft-deleted items" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore
+      }.should change(Android, :count).from(1).to(2)
+    end
+
+    it "should not hit update/save related callbacks" do
+      @r2d2.destroy
+
+      lambda{
+        @r2d2.update_attribute(:name, 'Robocop')
+      }.should raise_error
+
+      lambda{
+        @r2d2.restore
+      }.should_not raise_error
+    end
+
+    it "should restore dependent models when being restored by default" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore
+      }.should change(Component, :count).from(0).to(1)
+    end
+
+    it "should provide the option to not restore dependent models" do
+      @r2d2.destroy
+      lambda{
+        @r2d2.restore(:include_destroyed_dependents => false)
+      }.should_not change(Component, :count)
+    end
+
+    it "should restore parent and child models specified via :include" do
+      sub_component = SubComponent.create(:name => 'part', :component_id => @r2d2.components.first.id)
+      @r2d2.destroy
+      SubComponent.first(:conditions => {:id => sub_component.id}).should be_nil
+      @r2d2.components.first.restore(:include => [:android, :sub_components])
+      SubComponent.first(:conditions => {:id => sub_component.id}).should_not be_nil
+      Android.find(@r2d2.id).should_not be_nil
+    end
+  end
+
+  describe 'validations' do
+    it "should not ignore destroyed items in validation checks unless scoped" do
+      # Androids are not validates_uniqueness_of scoped
+      @r2d2.destroy
+      lambda{
+        Android.create!(:name => 'R2D2')
+      }.should raise_error(ActiveRecord::RecordInvalid)
+
+      lambda{
+        # creating shouldn't raise an error
+        another_r2d2 = AndroidWithScopedUniqueness.create!(:name => 'R2D2')
+        # neither should destroying the second incarnation since the
+        # validates_uniqueness_of is only applied on create
+        another_r2d2.destroy
+      }.should_not raise_error
+    end
+  end
+
+  describe '(parent)_with_destroyed' do
+    it "should be able to access destroyed parents" do
+      # Memory is has_many with a non-default primary key
+      # Sticker is a has_one with a default primary key
+      [Memory, Sticker].each do |klass|
+        instance = klass.last
+        parent = instance.android
+        instance.android.destroy
+
+        # reload so the model doesn't remember the parent
+        instance.reload
+        instance.android.should == nil
+        instance.android_with_destroyed.should == parent
+      end
+    end
+
+		it "should be able to access destroyed children" do
+			comps = @r2d2.components
+			comps.to_s # I have no idea why this makes it pass, but hey, here it is
+			@r2d2.components.first.destroy
+			@r2d2.components_with_destroyed.should == comps
+		end
+
+    it "should return nil if no destroyed parent exists" do
+      sticker = Sticker.new(:name => 'Rainbows')
+      # because the default relationship works this way, i.e.
+      sticker.android.should == nil
+      sticker.android_with_destroyed.should == nil
+    end
+
+    it "should not break method_missing's defined before the is_paranoid call" do
+      # we've defined a method_missing on Sticker
+      # that changes the sticker name.
+      sticker = Sticker.new(:name => "Ponies!")
+      lambda{
+        sticker.some_crazy_method_that_we_certainly_do_not_respond_to
+      }.should change(sticker, :name).to(Sticker::MM_NAME)
+    end
+  end
+
+  describe 'alternate fields and field values' do
+    it "should properly function for boolean values" do
+      # ninjas are invisible by default.  not being ninjas, we can only
+      # find those that are visible
+      ninja = Ninja.create(:name => 'Esteban', :visible => true)
+      ninja.vanish # aliased to destroy
+      Ninja.first.should be_blank
+      Ninja.find_with_destroyed(:first).should == ninja
+      Ninja.count.should == 0
+
+      # we're only interested in pirates who are alive by default
+      pirate = Pirate.create(:name => 'Reginald')
+      pirate.destroy
+      Pirate.first.should be_blank
+      Pirate.find_with_destroyed(:first).should == pirate
+      Pirate.count.should == 0
+
+      # we're only interested in pirates who are dead by default.
+      # zombie pirates ftw!
+      DeadPirate.first.id.should == pirate.id
+      lambda{
+        DeadPirate.first.destroy
+      }.should change(Pirate, :count).from(0).to(1)
+      DeadPirate.count.should == 0
+    end
+  end
+
+  describe 'after_destroy and before_destroy callbacks' do
+    it "should rollback if before_destroy fails" do
+      edward = UndestroyablePirate.create(:name => 'Edward')
+      lambda{
+        edward.destroy
+      }.should_not change(UndestroyablePirate, :count)
+    end
+
+    it "should rollback if after_destroy raises an error" do
+      raul = RandomPirate.create(:name => 'Raul')
+      lambda{
+        begin
+          raul.destroy
+        rescue => ex
+          ex.message.should == 'after_destroy works'
+        end
+      }.should_not change(RandomPirate, :count)
+    end
+
+    it "should handle callbacks normally assuming no failures are encountered" do
+      component = Component.first
+      lambda{
+        component.destroy
+      }.should change(component, :name).to(Component::NEW_NAME)
+    end
+
+  end
+end

data/spec/models.rb

@@ -0,0 +1,94 @@
+class Person < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name
+  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
+end
+
+class Android < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name
+  has_many :components, :dependent => :destroy
+  has_one :sticker
+  has_many :memories, :foreign_key => 'parent_id'
+
+  is_paranoid
+
+  # this code is to ensure that our destroy and restore methods
+  # work without triggering before/after_update callbacks
+  before_update :raise_hell
+  def raise_hell
+    raise "hell"
+  end
+end
+
+class Component < ActiveRecord::Base #:nodoc:
+  is_paranoid
+  belongs_to :android, :dependent => :destroy
+  has_many :sub_components, :dependent => :destroy
+  NEW_NAME = 'Something Else!'
+
+  after_destroy :change_name
+  def change_name
+    self.update_attribute(:name, NEW_NAME)
+  end
+end
+
+class SubComponent < ActiveRecord::Base #:nodoc:
+  is_paranoid
+  belongs_to :component, :dependent => :destroy
+end
+
+class Memory < ActiveRecord::Base #:nodoc:
+  is_paranoid
+  belongs_to :android, :class_name => "Android", :foreign_key => "parent_id"
+end
+
+class Sticker < ActiveRecord::Base #:nodoc
+  MM_NAME = "You've got method_missing"
+
+  # this simply serves to ensure that we don't break method_missing
+  # if it is implemented on a class and called before is_paranoid
+  def method_missing name, *args, &block
+    self.name = MM_NAME
+  end
+
+  is_paranoid
+  belongs_to :android
+end
+
+class AndroidWithScopedUniqueness < ActiveRecord::Base #:nodoc:
+  set_table_name :androids
+  validates_uniqueness_of :name, :scope => :deleted_at
+  is_paranoid
+end
+
+class Ninja < ActiveRecord::Base #:nodoc:
+  validates_uniqueness_of :name, :scope => :visible
+  is_paranoid :field => [:visible, false, true]
+  
+  alias_method :vanish, :destroy
+end
+
+class Pirate < ActiveRecord::Base #:nodoc:
+  is_paranoid :field => [:alive, false, true]
+end
+
+class DeadPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  is_paranoid :field => [:alive, true, false]
+end
+
+class RandomPirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+
+  def after_destroy
+    raise 'after_destroy works'
+  end
+end
+
+class UndestroyablePirate < ActiveRecord::Base #:nodoc:
+  set_table_name :pirates
+  is_paranoid :field => [:alive, false, true]
+
+  def before_destroy
+    false
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,51 @@
+ActiveRecord::Schema.define(:version => 20090317164830) do
+  create_table "androids", :force => true do |t|
+    t.string   "name"
+    t.integer  "owner_id"
+    t.datetime "deleted_at"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "people", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "components", :force => true do |t|
+    t.string   "name"
+    t.integer  "android_id"
+    t.datetime "deleted_at"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "sub_components", :force => true do |t|
+    t.string "name"
+    t.integer "component_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "memories", :force => true do |t|
+    t.string   "name"
+    t.integer  "parent_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "stickers", :force => true do |t|
+    t.string   "name"
+    t.integer  "android_id"
+    t.datetime "deleted_at"
+  end
+
+  create_table "ninjas", :force => true do |t|
+    t.string   "name"
+    t.boolean  "visible", :default => false
+  end
+
+  create_table "pirates", :force => true do |t|
+    t.string   "name"
+    t.boolean  "alive", :default => true
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require "#{File.dirname(__FILE__)}/../lib/is_paranoid"
+require 'activerecord'
+require 'yaml'
+require 'spec'
+
+def connect(environment)
+  conf = YAML::load(File.open(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.establish_connection(conf[environment])
+end
+
+# Open ActiveRecord connection
+connect('test')
+load(File.dirname(__FILE__) + "/schema.rb")

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: amiel-is_paranoid
+version: !ruby/object:Gem::Version 
+  version: 0.9.2
+platform: ruby
+authors: 
+- Jeffrey Chupp
+- Amiel Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-14 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: amiel.martin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/is_paranoid.rb
+- spec/database.yml
+- spec/is_paranoid_spec.rb
+- spec/models.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jchupp/is_paranoid/
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: 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.
+test_files: 
+- spec/is_paranoid_spec.rb
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb