woods-is_paranoid 0.0.2

data/README.textile

@@ -0,0 +1,76 @@
+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 deleted_at timestamp column on its database table.  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.
+
+<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 :with_calculations => true
+end
+</pre>
+
+Now our automobiles are now soft-deleteable.  In fact, that's more complicated than necessary since you don't have to use :with_calculations => true unless you want to get special calculation methods extended off of ActiveRecord::Calculations like count_with_destroyed and sum_with_destroyed.
+
+<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.
+
+<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>
+
+h3. Note:
+
+  validates_uniqueness_of does not ignore items marked with a deleted_at flag.  This is a behavior difference between is_paranoid and acts_as_paranoid.  I'm going to treat this as a bug until I get a chance to make it an optional feature.  Be aware of it.
+
+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:
+* deal with validates_uniqueness_of issue
+* 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/VERSION.yml

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

data/lib/is_paranoid.rb

@@ -0,0 +1,93 @@
+require 'activerecord'
+
+module IsParanoid
+  def self.included(base) # :nodoc:
+    base.extend SafetyNet
+  end
+
+  module SafetyNet
+    # Call this in your model to enable all the safety-net goodness
+    #
+    #  Example:
+    #
+    #  class Android < ActiveRecord::Base
+    #    is_paranoid
+    #  end
+    #
+    # If you want to include ActiveRecord::Calculations to include your
+    # destroyed models, do is_paranoid :with_calculations => true and you
+    # will get sum_with_deleted, count_with_deleted, etc.
+    def is_paranoid opts = {}
+      class_eval do
+        # This is the real magic.  All calls made to this model will append
+        # the conditions deleted_at => nil.  Exceptions require using
+        # exclusive_scope (see self.delete_all, self.count_with_destroyed,
+        # and self.find_with_destroyed )
+        default_scope :conditions => {:deleted_at => nil}
+
+        # 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 self.delete_all conditions = nil
+          self.with_exclusive_scope do
+            super conditions
+          end
+        end
+
+        # Return instances of all models matching the query regardless
+        # of whether or not they have been soft-deleted.
+        def self.find_with_destroyed *args
+          self.with_exclusive_scope { find(*args) }
+        end
+        
+        # Returns all destroyed views
+        def self.find_only_destroyed *args
+          self.with_exclusive_scope { with_only_destroyed_scope { find(*args) } }
+        end
+        
+        # Mark the model deleted_at as now.
+        def destroy_without_callbacks
+          self.update_attribute(:deleted_at, Time.now.utc)
+        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)
+          result
+        end
+
+        # Set deleted_at flag on a model to nil, effectively undoing the
+        # soft-deletion.
+        def restore
+          self.update_attribute(:deleted_at, nil)
+        end
+        
+        protected
+        
+        def self.with_only_destroyed_scope(&block)
+          with_scope({:find => { :conditions => ["deleted_at IS NOT NULL"] }}, &block)
+        end
+      end
+
+      if opts[:with_calculations]
+        self.extend(Module.new{
+          [:average, :calculate, :construct_count_options_from_args,
+          :count, :maximum, :minimum, :sum].each do |method|          # EXAMPLE OUTPUT:
+            define_method "#{method}_with_destroyed" do |*args|       #  def count_with_destroyed(*args)
+              self.with_exclusive_scope{ self.send(method, *args) }   #     self.with_exclusive_scope{ self.send(:count, *args) }
+            end                                                       #  end
+          end
+        })
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, IsParanoid)

data/spec/database.yml

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

data/spec/is_paranoid_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class Person < ActiveRecord::Base
+  has_many :androids, :foreign_key => :owner_id, :dependent => :destroy
+end
+
+class Android < ActiveRecord::Base
+  validates_uniqueness_of :name
+  is_paranoid :with_calculations => true
+end
+
+class NoCalculation < ActiveRecord::Base
+  is_paranoid
+end
+
+describe Android do
+  before(:each) do
+    Android.delete_all
+    Person.delete_all
+
+    @luke = Person.create(:name => 'Luke Skywalker')
+    @r2d2 = Android.create(:name => 'R2D2', :owner_id => @luke.id)
+    @c3p0 = Android.create(:name => 'C3P0', :owner_id => @luke.id)
+  end
+
+  it "should delete normally" do
+    Android.count_with_destroyed.should == 2
+    Android.delete_all
+    Android.count_with_destroyed.should == 0
+  end
+
+  it "should handle Model.destroy_all properly" do
+    lambda{
+      Android.destroy_all("owner_id = #{@luke.id}")
+    }.should change(Android, :count).from(2).to(0)
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should handle Model.destroy(id) properly" do
+    lambda{
+      Android.destroy(@r2d2.id)
+    }.should change(Android, :count).from(2).to(1)
+
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should be not show up in the relationship to the owner once deleted" do
+    @luke.androids.size.should == 2
+    @r2d2.destroy
+    @luke.androids.size.should == 1
+    Android.count.should == 1
+    Android.first(:conditions => {:name => 'R2D2'}).should be_blank
+  end
+
+  it "should be able to find deleted items via find_with_destroyed" do
+    @r2d2.destroy
+    Android.find(:first, :conditions => {:name => 'R2D2'}).should be_blank
+    Android.find_with_destroyed(:first, :conditions => {:name => 'R2D2'}).should_not be_blank
+  end
+
+  it "should have a proper count inclusively and exclusively of deleted items" do
+    @r2d2.destroy
+    @c3p0.destroy
+    Android.count.should == 0
+    Android.count_with_destroyed.should == 2
+  end
+
+  it "should mark deleted on dependent destroys" do
+    lambda{
+      @luke.destroy
+    }.should change(Android, :count).from(2).to(0)
+    Android.count_with_destroyed.should == 2
+  end
+  
+  it "should allow restoring" do
+    @r2d2.destroy
+    lambda{
+      @r2d2.restore
+    }.should change(Android, :count).from(1).to(2)
+  end
+  
+  it "should find only destroyed videos" do
+    @r2d2.destroy
+    Android.find_only_destroyed(:all).should == [@r2d2]
+  end
+
+  it "should respond to various calculations if we specify that we want them" do
+    NoCalculation.respond_to?(:sum_with_destroyed).should == false
+    Android.respond_to?(:sum_with_destroyed).should == true
+
+    @r2d2.destroy
+    Android.sum('id').should == @c3p0.id
+    Android.sum_with_destroyed('id').should == @r2d2.id + @c3p0.id
+  end
+
+  # Note:  this isn't necessarily ideal, this just serves to demostrate
+  # how it currently works
+  it "should not ignore deleted items in validation checks" do
+    @r2d2.destroy
+    lambda{
+      Android.create!(:name => 'R2D2')
+    }.should raise_error(ActiveRecord::RecordInvalid)
+  end
+  
+end

data/spec/schema.rb

@@ -0,0 +1,15 @@
+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
+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,61 @@
+--- !ruby/object:Gem::Specification 
+name: woods-is_paranoid
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jeffrey Chupp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: jeff@semanticart.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- VERSION.yml
+- lib/is_paranoid.rb
+- spec/database.yml
+- spec/is_paranoid_spec.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jchupp/is_paranoid/
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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.2.0
+signing_key: 
+specification_version: 2
+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: []
+