Name: paranoia
Owner: Rainforest QA
Description: acts_as_paranoid for Rails 3 & 4
Created: 2015-02-10 01:33:22.0
Updated: 2016-02-08 20:21:02.0
Pushed: 2016-04-08 00:00:28.0
Size: 330
Language: Ruby
GitHub Committers
User | Most Recent Commit | # Commits |
---|
Other Committers
User | Most Recent Commit | # Commits |
---|
Paranoia is a re-implementation of acts_as_paranoid for Rails 3/4/5, using much, much, much less code.
When your app is using Paranoia, calling destroy
on an ActiveRecord object doesn't actually destroy the database record, but just hides it. Paranoia does this by setting a deleted_at
field to the current time when you destroy
a record, and hides it by scoping all queries on your model to only include records which do not have a deleted_at
field.
If you wish to actually destroy an object you may call really_destroy!
. WARNING: This will also really destroy all dependent: :destroy
records, so please aim this method away from face when using.
If a record has has_many
associations defined AND those associations have dependent: :destroy
set on them, then they will also be soft-deleted if acts_as_paranoid
is set, otherwise the normal destroy will be called.
Setup and basic usage of the paranoia gem GoRails #41
For Rails 3, please use version 1 of Paranoia:
"paranoia", "~> 1.0"
For Rails 4 or 5, please use version 2 of Paranoia:
"paranoia", "~> 2.0"
Of course you can install this from GitHub as well:
"paranoia", :github => "radar/paranoia", :branch => "rails3"
"paranoia", :github => "radar/paranoia", :branch => "rails4"
Then run:
le install
Updating is as simple as bundle update paranoia
.
Run:
s generate migration AddDeletedAtToClients deleted_at:datetime:index
and now you have a migration
s AddDeletedAtToClients < ActiveRecord::Migration
f change
add_column :clients, :deleted_at, :datetime
add_index :clients, :deleted_at
d
s Client < ActiveRecord::Base
ts_as_paranoid
...
Hey presto, it's there! Calling destroy
will now set the deleted_at
column:
lient.deleted_at
nil
lient.destroy
client
lient.deleted_at
[current timestamp]
If you really want it gone gone, call really_destroy!
:
lient.deleted_at
nil
lient.really_destroy!
client
If you want to use a column other than deleted_at
, you can pass it as an option:
s Client < ActiveRecord::Base
ts_as_paranoid column: :destroyed_at
.
If you want to skip adding the default scope:
s Client < ActiveRecord::Base
ts_as_paranoid without_default_scope: true
.
If you want to access soft-deleted associations, override the getter method:
product
oduct.unscoped { super }
If you want to include associated soft-deleted objects, you can (un)scope the association:
s Person < ActiveRecord::Base
longs_to :group, -> { with_deleted }
on.includes(:group).all
If you want to find all records, even those which are deleted:
nt.with_deleted
If you want to exclude deleted records, when not able to use the default_scope (e.g. when using without_default_scope):
nt.without_deleted
If you want to find only the deleted records:
nt.only_deleted
If you want to check if a record is soft-deleted:
nt.paranoia_destroyed?
nt.deleted?
If you want to restore a record:
nt.restore(id)
nt.restore
If you want to restore a whole bunch of records:
nt.restore([id1, id2, ..., idN])
If you want to restore a record and their dependently destroyed associated records:
nt.restore(id, :recursive => true)
nt.restore(:recursive => true)
For more information, please look at the tests.
Beware that you should adapt all your indexes for them to work as fast as previously. For example,
index :clients, :group_id
index :clients, [:group_id, :other_id]
should be replaced with
index :clients, :group_id, where: "deleted_at IS NULL"
index :clients, [:group_id, :other_id], where: "deleted_at IS NULL"
Of course, this is not necessary for the indexes you always use in association with with_deleted
or only_deleted
.
Because NULL != NULL in standard SQL, we can not simply create a unique index on the deleted_at column and expect it to enforce that there only be one record with a certain combination of values.
If your database supports them, good alternatives include partial indexes (above) and indexes on computed columns. E.g.
index :clients, [:group_id, 'COALESCE(deleted_at, false)'], unique: true
If not, an alternative is to create a separate column which is maintained alongside deleted_at for the sake of enforcing uniqueness. To that end, paranoia makes use of two method to make its destroy and restore actions: paranoia_restore_attributes and paranoia_destroy_attributes.
column :clients, :active, :boolean
index :clients, [:group_id, :active], unique: true
s Client < ActiveRecord::Base
optionally have paranoia make use of your unique column, so that
your lookups will benefit from the unique index
ts_as_paranoid column: :active, sentinel_value: true
f paranoia_restore_attributes
{
deleted_at: nil,
active: true
}
d
f paranoia_destroy_attributes
{
deleted_at: current_time_from_proper_timezone,
active: nil
}
d
You can replace the older acts_as_paranoid
methods as follows:
| Old Syntax | New Syntax |
|:————————– |:—————————— |
|find_with_deleted(:all)
| Client.with_deleted
|
|find_with_deleted(:first)
| Client.with_deleted.first
|
|find_with_deleted(id)
| Client.with_deleted.find(id)
|
The recover
method in acts_as_paranoid
runs update
callbacks. Paranoia's
restore
method does not do this.
Paranoia provides several callbacks. It triggers destroy
callback when the record is marked as deleted and real_destroy
when the record is completely removed from database. It also calls restore
callback when the record is restored via paranoia
For example if you want to index your records in some search engine you can go like this:
s Product < ActiveRecord::Base
ts_as_paranoid
ter_destroy :update_document_in_search_engine
ter_restore :update_document_in_search_engine
ter_real_destroy :remove_document_from_search_engine
You can use these events just like regular Rails callbacks with before, after and around hooks.
This gem is released under the MIT license.