@@ -24,7 +24,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. === -Based on acts_as_paranoid +Based on ideas from acts_as_paranoid http://rubyforge.org/projects/ar-paranoid/ Copyright (c) 2005 Rick Olson MIT-LICENSE @@ -8,32 +8,32 @@ If you find a bug, a test exposing the bug would be great. acts_as_indestructible aims to be an alternate version of the acts_as_paranoid plugin idea, which is to mark ActiveRecord objects - as deleted instead of actually deleting them from the database. + as destroyed instead of actually deleting them from the database. - After an object is marked as deleted it should be excluded from + After an object is marked as destroyed it should be excluded from all of the ActiveRecord method calls and act as if it - was actually deleted from the database. + was deleted from the database. = Differences from acts_as_paranoid - 1. acts_as_indestructible fills the deleted_at field as well - as deleted_by + 1. acts_as_indestructible fills the destroyed_at field as well + as destroyed_by 2. destroy() and destroy_all(conditions=nil) have a user parameter, making them destroy(user) and destroy_all(user,conditions=nil). The user parameter is an ActiveRecord user object and - the user.id is stored in the deleted_by column. + the user.id is stored in the destroyed_by column. 3. acts_as_paranoid overrides protected and private ActiveRecord::Base methods which could change at any time. - acts_as_indestructible will attempt to provide the + acts_as_indestructible will work to provide the same function while using the public API contract that will not change within major Rails versions. 4. delete() and delete_all() throw exceptions and are effectively deprecated, which prevents developers from permanently deleting - objects this way. + objects this way. Raw SQL could still delete objects permanently. = Major plugin goals README @@ -5,8 +5,8 @@ class CreateIndestructiblePosts < ActiveRecord::Migration t.datetime :created_by t.datetime :updated_at t.datetime :updated_by - t.datetime :deleted_at - t.datetime :deleted_by + t.datetime :destroyed_at + t.datetime :destroyed_by t.string :title t.text :body end db/migrate/001_create_indestructible_posts.rb @@ -5,8 +5,8 @@ class CreateIndestructibleComments < ActiveRecord::Migration t.datetime :created_by t.datetime :updated_at t.datetime :updated_by - t.datetime :deleted_at - t.datetime :deleted_by + t.datetime :destroyed_at + t.datetime :destroyed_by t.integer :post_id t.text :body end db/migrate/002_create_indestructible_comments.rb @@ -5,8 +5,8 @@ class CreateIndestructibleUsers < ActiveRecord::Migration t.datetime :created_by t.datetime :updated_at t.datetime :updated_by - t.datetime :deleted_at - t.datetime :deleted_by + t.datetime :destroyed_at + t.datetime :destroyed_by t.string :username t.boolean :is_admin, :default => false end db/migrate/003_create_indestructible_users.rb @@ -33,7 +33,7 @@ module ActiveRecord #:nodoc: end def calculate(operation, column_name, options = {}) - super_calculate(operation, column_name, options_excluding_deleted(options)) + super_calculate(operation, column_name, options_excluding_destroyed(options)) end def exists?(id_or_conditions, options = {}) @@ -47,7 +47,7 @@ module ActiveRecord #:nodoc: when Hash include_destroyed = (id_or_conditions.has_key? :include_destroyed and id_or_conditions[:include_destroyed]) unless include_destroyed - id_or_conditions[:deleted_at] = nil + id_or_conditions[:destroyed_at] = nil end id_or_conditions.delete :include_destroyed end @@ -57,10 +57,10 @@ module ActiveRecord #:nodoc: #protected def destroyed_condition - "#{quoted_table_name}.deleted_at IS NULL" + "#{quoted_table_name}.destroyed_at IS NULL" end - def options_excluding_deleted(options) + def options_excluding_destroyed(options) options = Hash.new if options.nil? if options.has_key?(:conditions) if options[:conditions].instance_of? Array @@ -79,14 +79,14 @@ module ActiveRecord #:nodoc: module InstanceMethods def destroyed? - !self[:deleted_at].nil? + !self[:destroyed_at].nil? end def destroy(user) return if user.nil? or !user.is_a? ActiveRecord::Base # ...more conditions? return if destroyed? - self[:deleted_at] = Time.now - self[:deleted_by] = user.id + self[:destroyed_at] = Time.now + self[:destroyed_by] = user.id save end lib/acts_as_indestructible.rb @@ -3,11 +3,11 @@ goodbye: post: hello body: Bye. -deleted: - deleted_at: <%= 3.days.ago.to_s :db %> - deleted_by: 1 +destroyed: + destroyed_at: <%= 3.days.ago.to_s :db %> + destroyed_by: ryanlowe post: hello body: I regretted making this comment. -deleted_post: - post: deleted +destroyed_post: + post: destroyed body: On a deleted post. \ No newline at end of file test/fixtures/indestructible_comments.yml @@ -1,6 +1,7 @@ -deleted: - deleted_at: <%= 2.days.ago.to_s :db %> +destroyed: + destroyed_at: <%= 2.days.ago.to_s :db %> + destroyed_by: ryanlowe title: Destroyed Post body: This post is destroyed hello: test/fixtures/indestructible_posts.yml @@ -1,9 +1,7 @@ # Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html ryanlowe: - id: 1 username: ryanlowe is_admin: true tigerwoods: - id: 2 username: tigerwoods \ No newline at end of file test/fixtures/indestructible_users.yml @@ -4,12 +4,12 @@ class ActsAsIndestructibleTest < Test::Unit::TestCase fixtures :indestructible_users, :indestructible_posts, :indestructible_comments def test_fixtures_destroyed? - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? assert !indestructible_comments(:goodbye).destroyed? - assert indestructible_comments(:deleted).destroyed? - assert !indestructible_comments(:deleted_post).destroyed? + assert indestructible_comments(:destroyed).destroyed? + assert !indestructible_comments(:destroyed_post).destroyed? end end \ No newline at end of file test/unit/acts_as_indestructible_test.rb @@ -20,7 +20,7 @@ class DeleteTest < Test::Unit::TestCase end def test_delete_all_not_allowed - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? assert IndestructiblePost.exists?(indestructible_posts(:hello).id) @@ -29,12 +29,12 @@ class DeleteTest < Test::Unit::TestCase } assert IndestructiblePost.exists?(indestructible_posts(:hello).id) - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).reload.destroyed? end def test_delete_all_with_conditions_not_allowed - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? assert IndestructiblePost.exists?(indestructible_posts(:hello).id) @@ -43,7 +43,7 @@ class DeleteTest < Test::Unit::TestCase } assert IndestructiblePost.exists?(indestructible_posts(:hello).id) - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).reload.destroyed? end test/unit/delete_test.rb @@ -16,14 +16,14 @@ class DestroyTest < Test::Unit::TestCase end def test_destroy_already_destroyed - assert indestructible_posts(:deleted).destroyed? - time = indestructible_posts(:deleted)[:deleted_at] + assert indestructible_posts(:destroyed).destroyed? + time = indestructible_posts(:destroyed)[:destroyed_at] assert_not_nil time - indestructible_posts(:deleted).destroy(indestructible_users(:ryanlowe)) + indestructible_posts(:destroyed).destroy(indestructible_users(:ryanlowe)) - assert indestructible_posts(:deleted).destroyed? - assert_equal time, indestructible_posts(:deleted)[:deleted_at] + assert indestructible_posts(:destroyed).destroyed? + assert_equal time, indestructible_posts(:destroyed)[:destroyed_at] end def test_destroy_nil_user @@ -47,12 +47,12 @@ class DestroyTest < Test::Unit::TestCase # def test_destroy_all - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? IndestructiblePost.destroy_all(indestructible_users(:ryanlowe)) - assert indestructible_posts(:deleted).reload.destroyed? + assert indestructible_posts(:destroyed).reload.destroyed? assert indestructible_posts(:hello).reload.destroyed? end @@ -61,22 +61,22 @@ class DestroyTest < Test::Unit::TestCase end def test_destroy_all_nil_user - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? IndestructiblePost.destroy_all(nil) - assert indestructible_posts(:deleted).reload.destroyed? + assert indestructible_posts(:destroyed).reload.destroyed? assert !indestructible_posts(:hello).reload.destroyed? end def test_destroy_all_not_user - assert indestructible_posts(:deleted).destroyed? + assert indestructible_posts(:destroyed).destroyed? assert !indestructible_posts(:hello).destroyed? IndestructiblePost.destroy_all(Object.new) - assert indestructible_posts(:deleted).reload.destroyed? + assert indestructible_posts(:destroyed).reload.destroyed? assert !indestructible_posts(:hello).reload.destroyed? end test/unit/destroy_test.rb @@ -1,6 +1,6 @@ require File.dirname(__FILE__) + '/../test_helper' -class OptionsTest < ActiveSupport::TestCase +class ExistsTest < ActiveSupport::TestCase fixtures :indestructible_posts # @@ -40,11 +40,11 @@ class OptionsTest < ActiveSupport::TestCase # def test_exists_destroyed_integer - assert !IndestructiblePost.exists?(indestructible_posts(:deleted).id) + assert !IndestructiblePost.exists?(indestructible_posts(:destroyed).id) end def test_exists_destroyed_string - assert !IndestructiblePost.exists?(indestructible_posts(:deleted).id.to_s) + assert !IndestructiblePost.exists?(indestructible_posts(:destroyed).id.to_s) end def test_exists_destroyed_with_hash_conditions @@ -60,11 +60,11 @@ class OptionsTest < ActiveSupport::TestCase # def test_exists_excluding_destroyed_integer - assert !IndestructiblePost.exists?(indestructible_posts(:deleted).id, :include_destroyed => false) + assert !IndestructiblePost.exists?(indestructible_posts(:destroyed).id, :include_destroyed => false) end def test_exists_excluding_destroyed_string - assert !IndestructiblePost.exists?(indestructible_posts(:deleted).id.to_s, :include_destroyed => false) + assert !IndestructiblePost.exists?(indestructible_posts(:destroyed).id.to_s, :include_destroyed => false) end def test_exists_excluding_destroyed_with_hash_conditions @@ -80,11 +80,11 @@ class OptionsTest < ActiveSupport::TestCase # def test_exists_including_destroyed_integer - assert IndestructiblePost.exists?(indestructible_posts(:deleted).id, :include_destroyed => true) + assert IndestructiblePost.exists?(indestructible_posts(:destroyed).id, :include_destroyed => true) end def test_exists_including_destroyed_string - assert IndestructiblePost.exists?(indestructible_posts(:deleted).id, :include_destroyed => true) + assert IndestructiblePost.exists?(indestructible_posts(:destroyed).id, :include_destroyed => true) end def test_exists_including_destroyed_with_hash_conditions test/unit/exists_test.rb @@ -5,11 +5,11 @@ class IndestructibleCommentTest < ActiveSupport::TestCase def test_fixtures assert indestructible_comments(:goodbye).valid? - assert indestructible_comments(:deleted).valid? - assert indestructible_comments(:deleted_post).valid? + assert indestructible_comments(:destroyed).valid? + assert indestructible_comments(:destroyed_post).valid? - assert_equal indestructible_posts(:hello), indestructible_comments(:goodbye).post - assert_equal indestructible_posts(:hello), indestructible_comments(:deleted).post - assert_equal indestructible_posts(:deleted), indestructible_comments(:deleted_post).post + assert_equal indestructible_posts(:hello), indestructible_comments(:goodbye).post + assert_equal indestructible_posts(:hello), indestructible_comments(:destroyed).post + assert_equal indestructible_posts(:destroyed), indestructible_comments(:destroyed_post).post end end test/unit/indestructible_comment_test.rb @@ -4,7 +4,7 @@ class IndestructiblePostTest < ActiveSupport::TestCase fixtures :indestructible_posts def test_fixtures - assert indestructible_posts(:deleted).valid? + assert indestructible_posts(:destroyed).valid? assert indestructible_posts(:hello).valid? end test/unit/indestructible_post_test.rb @@ -3,51 +3,51 @@ require File.dirname(__FILE__) + '/../test_helper' class OptionsTest < ActiveSupport::TestCase # - # options_excluding_deleted + # options_excluding_destroyed # - def test_options_excluding_deleted_no_options - expected_default = { :conditions => "indestructible_posts.deleted_at IS NULL" } - assert_equal expected_default, IndestructiblePost.options_excluding_deleted(Hash.new) - assert_equal expected_default, IndestructiblePost.options_excluding_deleted(nil) + def test_options_excluding_destroyed_no_options + expected_default = { :conditions => "indestructible_posts.destroyed_at IS NULL" } + assert_equal expected_default, IndestructiblePost.options_excluding_destroyed(Hash.new) + assert_equal expected_default, IndestructiblePost.options_excluding_destroyed(nil) end - def test_options_excluding_deleted_no_conditions - expected_default = { :conditions => "indestructible_posts.deleted_at IS NULL" } + def test_options_excluding_destroyed_no_conditions + expected_default = { :conditions => "indestructible_posts.destroyed_at IS NULL" } expected_with_order = expected_default.clone expected_with_order[:order] = "id DESC" - assert_equal expected_with_order, IndestructiblePost.options_excluding_deleted({ :order => "id DESC" }) + assert_equal expected_with_order, IndestructiblePost.options_excluding_destroyed({ :order => "id DESC" }) expected_with_group = expected_default.clone expected_with_group[:group] = "title" - assert_equal expected_with_group, IndestructiblePost.options_excluding_deleted({ :group => "title" }) + assert_equal expected_with_group, IndestructiblePost.options_excluding_destroyed({ :group => "title" }) end - def test_options_excluding_deleted_with_string_conditions - expected = { :conditions => "indestructible_posts.deleted_at IS NULL AND 1=1" } + def test_options_excluding_destroyed_with_string_conditions + expected = { :conditions => "indestructible_posts.destroyed_at IS NULL AND 1=1" } - assert_equal expected, IndestructiblePost.options_excluding_deleted({ :conditions => "1=1" }) + assert_equal expected, IndestructiblePost.options_excluding_destroyed({ :conditions => "1=1" }) end - def test_options_excluding_deleted_with_array_conditions - expected = { :conditions => ["indestructible_posts.deleted_at IS NULL AND 1=?","fried chicken"] } + def test_options_excluding_destroyed_with_array_conditions + expected = { :conditions => ["indestructible_posts.destroyed_at IS NULL AND 1=?","fried chicken"] } - assert_equal expected, IndestructiblePost.options_excluding_deleted({ :conditions => ["1=?","fried chicken"] }) + assert_equal expected, IndestructiblePost.options_excluding_destroyed({ :conditions => ["1=?","fried chicken"] }) end - def test_options_excluding_deleted_with_string_conditions_and_deleted_at + def test_options_excluding_destroyed_with_string_conditions_and_destroyed_at #investigate: redundant but harmless? do databases optimize this out anyway? - expected = { :conditions => "indestructible_posts.deleted_at IS NULL AND deleted_at IS NULL AND 1=1" } + expected = { :conditions => "indestructible_posts.destroyed_at IS NULL AND destroyed_at IS NULL AND 1=1" } - assert_equal expected, IndestructiblePost.options_excluding_deleted({ :conditions => "deleted_at IS NULL AND 1=1" }) + assert_equal expected, IndestructiblePost.options_excluding_destroyed({ :conditions => "destroyed_at IS NULL AND 1=1" }) end - def test_options_excluding_deleted_with_array_conditions_and_deleted_at + def test_options_excluding_destroyed_with_array_conditions_and_destroyed_at #investigate: redundant but harmless? do databases optimize this out anyway? - expected = { :conditions => ["indestructible_posts.deleted_at IS NULL AND deleted_at IS NULL AND 1=?","fried chicken"] } + expected = { :conditions => ["indestructible_posts.destroyed_at IS NULL AND destroyed_at IS NULL AND 1=?","fried chicken"] } - assert_equal expected, IndestructiblePost.options_excluding_deleted({ :conditions => ["deleted_at IS NULL AND 1=?","fried chicken"] }) + assert_equal expected, IndestructiblePost.options_excluding_destroyed({ :conditions => ["destroyed_at IS NULL AND 1=?","fried chicken"] }) end end \ No newline at end of file test/unit/options_test.rb c08cf8e56452a427a00c589104727362e955d54d Ryan Lowe ryanlowe@gmail.com http://github.com/ryanlowe/acts_as_indestructible/commit/75b209cb6604b56e74eed5bc3a2cc78055196d2d 75b209cb6604b56e74eed5bc3a2cc78055196d2d 2008-05-22T00:25:40-07:00 2008-05-22T00:25:40-07:00 terminology: use destroyed everywhere instead of deleted' 3c59eef57d6e6bed2c07a6651873ceae6d82e8de Ryan Lowe ryanlowe@gmail.com