acts_as_trashable 1.0.3

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brian Durand
+
+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.rdoc

@@ -0,0 +1,37 @@
+= ActsAsTrashable
+
+This gem is designed to reduce the risk of adding a delete function to your application by allowing you to restore records that have been destroyed.
+
+Often it makes sense to add a function to delete records so that your production database isn't polluted with bad records. However, you can quickly regret this feature should one of your users get a little trigger happy and delete something they shouldn't have. Restoring the lost data from the database can be time consuming and may not even be possible. The inspiration for this gem was a user who didn't understand that the "reject" function deleted the data for everyone and not just from that user's view.
+
+To protect yourself, simply declare acts_as_trashable in any active record model. This will cause the record to be serialized to a trash_records table before it is deleted when you call destroy. In addition, any has_and_belongs_to_many associations or any has_many or has_one associations declared with :dependent => :destroy will also be serialized. These associations should not have acts_as_trashable (there's no harm if they do, you just end up with twice as much trash). You must run the included migration to create the trash_records table.
+
+== Restoring Records
+
+These trash records and all their associations can be restored later by calling restore! on the TrashRecord records. Calling restore! will also delete the TrashRecord. You can also call restore (without the exclamation) which will just restore the original record and associations to memory without saving to the database or deleting the trash. This can be useful if you only need to inspect the trash record or if you've changed the model since the original record was created so that requires some additional processing before it can be saved. If you have a record which cannot be restored due to validation errors, you can try calling save_without_validation on the restored record.
+
+  ActsAsTrashable::TrashRecord.find(id).restore.save_without_validation
+
+In many cases this should work just fine since presumably the record was valid when it was originally destroyed. When records are restored, the id values are also restored to the original values.
+
+The ActsAsTrashable::ClassMethods are mixed into your model when you call acts_as_trashable. These provide some convenience methods for restoring and emptying the trash for only a specific class.
+
+== Disabling
+
+If you wish to destroy a record without trashing it, perform the destroy inside a disable_trash block on the model (i.e. record.disable_trash{record.destroy}). Also, this gem does not affect the delete or delete_all methods on active record. These will still delete the records directly from the database.
+
+== Setup
+
+To create the table structure for ActsAsTrashable::TrashRecord, simply add a migration to your project that calls
+
+  ActsAsTrashable::TrashRecord.create_table
+
+== Keeping It Clean
+
+To keep your trash table from filling up, you can call empty_trash on TrashRecord or on any ActsAsTrashable model. These methods clear out records older than a specified number of seconds. Trashed records are compressed in the database to conserve the amount of disk space they take up.
+
+== Other Solutions
+
+Another method of solving the issue that this gem addresses is to add a status flag on your model and consider records with the flag set to be deleted (for example see ActsAsParanoid[http://ar-paranoid.rubyforge.org/]). This is definitely a safer method of keeping the records since the data is never actually deleted. However, it presents a more complicated solution and you'll need to guard against ever accidentally showing a deleted record. The best method to use will depend on your application.
+
+Finally, this gem has a companion gem ActsAsRevisionable[http://github.com/bdurand/acts_as_revisionable] that allows you to keep a history of revisions to records each time they get updated. Using both together gives you a more robust restoration system. They are not packaged together because some applications may not have a use for the revisioning but do need the protection against accidental deletion.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'spec/rake/spectask'
+  desc 'Test the gem.'
+  Spec::Rake::SpecTask.new(:test) do |t|
+    t.spec_files = FileList.new('spec/**/*_spec.rb')
+  end
+rescue LoadError
+  tast :test do
+    STDERR.puts "You must have rspec >= 1.3.0 to run the tests"
+  end
+end
+
+desc 'Generate documentation for the gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.options << '--title' << 'Acts As Trashable' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_trashable"
+    gem.summary = %Q{ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored.}
+    gem.description = %Q(ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored. This is intended to reduce the risk of users misusing your application's delete function and losing data.)
+    gem.email = "brian@embellishedvisions.com"
+    gem.homepage = "http://github.com/bdurand/acts_as_trashable"
+    gem.authors = ["Brian Durand"]
+    gem.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+    
+    gem.add_dependency('activerecord', '>= 2.2')
+    gem.add_development_dependency('sqlite3')
+    gem.add_development_dependency('rspec', '>= 1.3.0')
+    gem.add_development_dependency('jeweler')
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.3

data/acts_as_trashable.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{acts_as_trashable}
+  s.version = "1.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Durand"]
+  s.date = %q{2010-06-22}
+  s.description = %q{ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored. This is intended to reduce the risk of users misusing your application's delete function and losing data.}
+  s.email = %q{brian@embellishedvisions.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "acts_as_trashable.gemspec",
+     "lib/acts_as_trashable.rb",
+     "lib/acts_as_trashable/trash_record.rb",
+     "spec/acts_as_trashable_spec.rb",
+     "spec/full_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/trash_record_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/bdurand/acts_as_trashable}
+  s.rdoc_options = ["--charset=UTF-8", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored.}
+  s.test_files = [
+    "spec/acts_as_trashable_spec.rb",
+     "spec/full_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/trash_record_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.2"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.2"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 1.3.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.2"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 1.3.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

data/lib/acts_as_trashable/trash_record.rb

@@ -0,0 +1,166 @@
+require 'zlib'
+
+module ActsAsTrashable
+  class TrashRecord < ActiveRecord::Base
+
+    set_table_name "trash_records"
+  
+    class << self
+      # Find a trash entry by class and id.
+      def find_trash (klass, id)
+        find(:all, :conditions => {:trashable_type => klass.base_class.name, :trashable_id => id}).last
+      end
+
+      # Empty the trash by deleting records older than the specified maximum age. You can optionally specify
+      # :only or :except in the options hash with a class or array of classes as the value to limit the trashed
+      # classes which should be cleared. This is useful if you want to keep different classes for different
+      # lengths of time.
+      def empty_trash (max_age, options = {})
+        sql = 'created_at <= ?'
+        args = [max_age.ago]
+
+        vals = options[:only] || options[:except]
+        if vals
+          vals = [vals] unless vals.kind_of?(Array)
+          sql << ' AND trashable_type'
+          sql << ' NOT' unless options[:only]
+          sql << " IN (#{vals.collect{|v| '?'}.join(', ')})"
+          args.concat(vals.collect{|v| v.kind_of?(Class) ? v.base_class.name : v.to_s.camelize})
+        end
+
+        delete_all([sql] + args)
+      end
+      
+      def create_table
+        connection.create_table :trash_records do |t|
+          t.string :trashable_type, :null => false
+          t.integer :trashable_id, :null => false
+          t.binary :data, :limit => 5.megabytes
+          t.timestamp :created_at
+        end
+
+        connection.add_index :trash_records, [:trashable_type, :trashable_id], :name => "trashable"
+        connection.add_index :trash_records, [:created_at, :trashable_type], :name => "created_at_type"
+      end
+    end
+    
+    # Create a new trash record for the provided record.
+    def initialize (record)
+      super({})
+      self.trashable_type = record.class.base_class.name
+      self.trashable_id = record.id
+      self.data = Zlib::Deflate.deflate(Marshal.dump(serialize_attributes(record)))
+    end
+
+    # Restore a trashed record into an object. The record will not be saved.
+    def restore
+      restore_class = self.trashable_type.constantize
+    
+      # Check if we have a type field, if yes, assume single table inheritance and restore the actual class instead of the stored base class
+      sti_type = self.trashable_attributes[restore_class.inheritance_column]
+      if sti_type
+        begin
+          restore_class = self.trashable_type.send(:type_name_with_module, sti_type).constantize
+        rescue NameError
+          # Seems our assumption was wrong and we have no STI
+        end
+      end
+    
+      attrs, association_attrs = attributes_and_associations(restore_class, self.trashable_attributes)
+    
+      record = restore_class.new
+      attrs.each_pair do |key, value|
+        record.send("#{key}=", value)
+      end
+    
+      association_attrs.each_pair do |association, attribute_values|
+        restore_association(record, association, attribute_values)
+      end
+    
+      return record
+    end
+  
+    # Restore a trashed record into an object, save it, and delete the trash entry.
+    def restore!
+      record = self.restore
+      record.save!
+      self.destroy
+      return record
+    end
+
+    # Attributes of the trashed record as a hash.
+    def trashable_attributes
+      return nil unless self.data
+      uncompressed = Zlib::Inflate.inflate(self.data) rescue uncompressed = self.data # backward compatibility with uncompressed data
+      Marshal.load(uncompressed)
+    end
+  
+    private
+  
+    def serialize_attributes (record, already_serialized = {})
+      return if already_serialized["#{record.class}.#{record.id}"]
+      attrs = record.attributes.dup
+      already_serialized["#{record.class}.#{record.id}"] = true
+    
+      record.class.reflections.values.each do |association|
+        if association.macro == :has_many and [:destroy, :delete_all].include?(association.options[:dependent])
+          attrs[association.name] = record.send(association.name).collect{|r| serialize_attributes(r, already_serialized)}
+        elsif association.macro == :has_one and [:destroy, :delete_all].include?(association.options[:dependent])
+          associated = record.send(association.name)
+          attrs[association.name] = serialize_attributes(associated, already_serialized) unless associated.nil?
+        elsif association.macro == :has_and_belongs_to_many
+          attrs[association.name] = record.send("#{association.name.to_s.singularize}_ids".to_sym)
+        end
+      end
+    
+      return attrs
+    end
+  
+    def attributes_and_associations (klass, hash)
+      attrs = {}
+      association_attrs = {}
+    
+      hash.each_pair do |key, value|
+        if klass.reflections.include?(key)
+          association_attrs[key] = value
+        else
+          attrs[key] = value
+        end
+      end
+    
+      return [attrs, association_attrs]
+    end
+  
+    def restore_association (record, association, attributes)
+      reflection = record.class.reflections[association]
+      associated_record = nil
+      if reflection.macro == :has_many
+        if attributes.kind_of?(Array)
+          attributes.each do |association_attributes|
+            restore_association(record, association, association_attributes)
+          end
+        else
+          associated_record = record.send(association).build
+        end
+      elsif reflection.macro == :has_one
+        associated_record = reflection.klass.new
+        record.send("#{association}=", associated_record)
+      elsif reflection.macro == :has_and_belongs_to_many
+        record.send("#{association.to_s.singularize}_ids=", attributes)
+        return
+      end
+    
+      return unless associated_record
+    
+      attrs, association_attrs = attributes_and_associations(associated_record.class, attributes)
+      attrs.each_pair do |key, value|
+        associated_record.send("#{key}=", value)
+      end
+    
+      association_attrs.each_pair do |key, values|
+        restore_association(associated_record, key, values)
+      end
+    end
+  
+  end
+end

data/lib/acts_as_trashable.rb

@@ -0,0 +1,64 @@
+require 'active_record'
+require 'active_support/all'
+
+module ActsAsTrashable
+  
+  autoload :TrashRecord, File.expand_path('../acts_as_trashable/trash_record', __FILE__)
+  
+  def self.included (base)
+    base.extend(ActsMethods)
+  end
+  
+  module ActsMethods
+    # Class method that injects the trash behavior into the class.
+    def acts_as_trashable
+      extend ClassMethods
+      include InstanceMethods
+      alias_method_chain :destroy, :trash
+    end
+  end
+  
+  module ClassMethods
+    # Empty the trash for this class of all entries older than the specified maximum age in seconds.
+    def empty_trash (max_age)
+      TrashRecord.empty_trash(max_age, :only => self)
+    end
+    
+    # Restore a particular entry by id from the trash into an object in memory. The record will not be saved.
+    def restore_trash (id)
+      trash = TrashRecord.find_trash(self, id)
+      return trash.restore if trash
+    end
+    
+    # Restore a particular entry by id from the trash, save it, and delete the trash entry.
+    def restore_trash! (id)
+      trash = TrashRecord.find_trash(self, id)
+      return trash.restore! if trash
+    end
+  end
+  
+  module InstanceMethods
+    def destroy_with_trash
+      return destroy_without_trash if @acts_as_trashable_disabled
+      TrashRecord.transaction do
+        trash = TrashRecord.new(self)
+        trash.save!
+        return destroy_without_trash
+      end
+    end
+    
+    # Call this method to temporarily disable the trash feature within a block.
+    def disable_trash
+      save_val = @acts_as_trashable_disabled
+      begin
+        @acts_as_trashable_disabled = true
+        yield if block_given?
+      ensure
+        @acts_as_trashable_disabled = save_val
+      end
+    end
+  end
+  
+end
+
+ActiveRecord::Base.send(:include, ActsAsTrashable)

data/spec/acts_as_trashable_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ActsAsTrashable do
+  
+  before :all do
+    ActsAsTrashable::Test.create_database
+  end
+  
+  after :all do
+    ActsAsTrashable::Test.delete_database
+  end
+  
+  class TestTrashableModel
+    include ActsAsTrashable
+    
+    def destroy
+      really_destroy
+    end
+    
+    def really_destroy
+    end
+    
+    acts_as_trashable
+  end
+  
+  it "should be able to inject trashable behavior onto ActiveRecord::Base" do
+    ActiveRecord::Base.included_modules.should include(ActsAsTrashable)
+  end
+  
+  it "should create a trash entry when a model is destroyed" do
+    record = TestTrashableModel.new
+    trash = mock(:trash)
+    ActsAsTrashable::TrashRecord.should_receive(:transaction).and_yield
+    ActsAsTrashable::TrashRecord.should_receive(:new).with(record).and_return(trash)
+    trash.should_receive(:save!)
+    record.should_receive(:really_destroy).and_return(:retval)
+    record.destroy.should == :retval
+  end
+  
+  it "should not create a trash entry when a model is destroyed inside a disable block" do
+    record = TestTrashableModel.new
+    ActsAsTrashable::TrashRecord.should_not_receive(:transaction)
+    ActsAsTrashable::TrashRecord.should_not_receive(:new)
+    record.should_receive(:really_destroy).and_return(:retval)
+    record.disable_trash do
+      record.destroy.should == :retval
+    end
+  end
+  
+  it "should be able to empty the trash based on age" do
+    ActsAsTrashable::TrashRecord.should_receive(:empty_trash).with(1.day, :only => TestTrashableModel)
+    TestTrashableModel.empty_trash(1.day)
+  end
+  
+  it "should be able to restore a record by id" do
+    trash = mock(:trash)
+    record = mock(:record)
+    ActsAsTrashable::TrashRecord.should_receive(:find_trash).with(TestTrashableModel, 1).and_return(trash)
+    trash.should_receive(:restore).and_return(record)
+    TestTrashableModel.restore_trash(1).should == record
+  end
+  
+  it "should be able to restore a record by id and save it" do
+    trash = mock(:trash)
+    record = mock(:record)
+    ActsAsTrashable::TrashRecord.should_receive(:find_trash).with(TestTrashableModel, 1).and_return(trash)
+    trash.should_receive(:restore!).and_return(record)
+    TestTrashableModel.restore_trash!(1).should == record
+  end
+  
+end

data/spec/full_spec.rb

@@ -0,0 +1,258 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ActsAsTrashable Full Test" do
+  
+  before :all do
+    ActsAsTrashable::Test.create_database
+    
+    class TrashableTestSubThing < ActiveRecord::Base
+      connection.create_table(:trashable_test_sub_things) do |t|
+        t.column :name, :string
+        t.column :trashable_test_many_thing_id, :integer
+      end unless table_exists?
+    end
+
+    class TrashableTestManyThing < ActiveRecord::Base
+      connection.create_table(:trashable_test_many_things) do |t|
+        t.column :name, :string
+        t.column :trashable_test_model_id, :integer
+      end unless table_exists?
+    
+      has_many :sub_things, :class_name => 'TrashableTestSubThing', :dependent => :destroy
+    end
+
+    class TrashableTestManyOtherThing < ActiveRecord::Base
+      connection.create_table(:trashable_test_many_other_things) do |t|
+        t.column :name, :string
+        t.column :trashable_test_model_id, :integer
+      end unless table_exists?
+    end
+
+    class TrashableTestOneThing < ActiveRecord::Base
+      connection.create_table(:trashable_test_one_things) do |t|
+        t.column :name, :string
+        t.column :trashable_test_model_id, :integer
+      end unless table_exists?
+    end
+
+    class NonTrashableTestModel < ActiveRecord::Base
+      connection.create_table(:non_trashable_test_models) do |t|
+        t.column :name, :string
+      end unless table_exists?
+    end
+    
+    class NonTrashableTestModelsTrashableTestModel < ActiveRecord::Base
+      connection.create_table(:non_trashable_test_models_trashable_test_models, :id => false) do |t|
+        t.column :non_trashable_test_model_id, :integer
+        t.column :trashable_test_model_id, :integer
+      end unless table_exists?
+    end
+
+    class TrashableTestModel < ActiveRecord::Base
+      connection.create_table(:trashable_test_models) do |t|
+        t.column :name, :string
+        t.column :secret, :integer
+      end unless table_exists?
+    
+      has_many :many_things, :class_name => 'TrashableTestManyThing', :dependent => :destroy
+      has_many :many_other_things, :class_name => 'TrashableTestManyOtherThing'
+      has_one :one_thing, :class_name => 'TrashableTestOneThing', :dependent => :destroy
+      has_and_belongs_to_many :non_trashable_test_models
+  
+      attr_protected :secret
+      
+      acts_as_trashable
+      
+      def set_secret (val)
+        self.secret = val
+      end
+      
+      private
+      
+      def secret= (val)
+        self[:secret] = val
+      end
+    end
+    
+    module ActsAsTrashable
+      class TrashableNamespaceModel < ActiveRecord::Base
+        connection.create_table(:trashable_namespace_models) do |t|
+          t.column :name, :string
+          t.column :type_name, :string
+        end unless table_exists?
+        
+        set_inheritance_column :type_name
+        acts_as_trashable
+      end
+      
+      class TrashableSubclassModel < TrashableNamespaceModel
+      end
+    end
+  end
+  
+  after :all do
+    ActsAsTrashable::Test.delete_database
+  end
+  
+  before :each do
+    TrashableTestModel.delete_all
+    TrashableTestManyThing.delete_all
+    TrashableTestManyOtherThing.delete_all
+    TrashableTestSubThing.delete_all
+    TrashableTestOneThing.delete_all
+    NonTrashableTestModelsTrashableTestModel.delete_all
+    NonTrashableTestModel.delete_all
+    ActsAsTrashable::TrashRecord.delete_all
+    ActsAsTrashable::TrashableNamespaceModel.delete_all
+  end
+
+  it "should be able to trash a record and restore without associations" do
+    model = TrashableTestModel.new
+    model.name = 'test'
+    model.send :secret=, 123
+    model.save!
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    TrashableTestModel.count.should == 0
+    
+    restored = TrashableTestModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    restored.secret.should == 123
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestModel.count.should == 1
+  end
+  
+  it "should be able to disable trash behavior" do
+    model = TrashableTestModel.new
+    model.name = 'test'
+    model.save!
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    model.disable_trash do
+      model.destroy
+    end
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestModel.count.should == 0
+  end
+  
+  it "should be able to trash a record and restore it with has_many associations" do
+    many_thing_1 = TrashableTestManyThing.new(:name => 'many_thing_1')
+    many_thing_1.sub_things.build(:name => 'sub_thing_1')
+    many_thing_1.sub_things.build(:name => 'sub_thing_2')
+    
+    model = TrashableTestModel.new(:name => 'test')
+    model.many_things << many_thing_1
+    model.many_things.build(:name => 'many_thing_2')
+    model.many_other_things.build(:name => 'many_other_thing_1')
+    model.many_other_things.build(:name => 'many_other_thing_2')
+    model.save!
+    model.reload
+    TrashableTestManyThing.count.should == 2
+    TrashableTestSubThing.count.should == 2
+    TrashableTestManyOtherThing.count.should == 2
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    TrashableTestModel.count.should == 0
+    TrashableTestManyThing.count.should == 0
+    TrashableTestSubThing.count.should == 0
+    TrashableTestManyOtherThing.count.should == 2
+    
+    restored = TrashableTestModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    restored.many_things.collect{|t| t.name}.sort.should == ['many_thing_1', 'many_thing_2']
+    restored.many_things.detect{|t| t.name == 'many_thing_1'}.sub_things.collect{|t| t.name}.sort.should == ['sub_thing_1', 'sub_thing_2']
+    restored.many_other_things.collect{|t| t.name}.sort.should == ['many_other_thing_1', 'many_other_thing_2']
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestModel.count.should == 1
+    TrashableTestManyThing.count.should == 2
+    TrashableTestSubThing.count.should == 2
+    TrashableTestManyOtherThing.count.should == 2
+  end
+  
+  it "should be able to trash a record and restore it with has_one associations" do
+    model = TrashableTestModel.new(:name => 'test')
+    model.build_one_thing(:name => 'other')
+    model.save!
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestOneThing.count.should == 1
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    TrashableTestModel.count.should == 0
+    TrashableTestOneThing.count.should == 0
+    
+    restored = TrashableTestModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    restored.one_thing.name.should == 'other'
+    restored.one_thing.id.should == model.one_thing.id
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestModel.count.should == 1
+    TrashableTestOneThing.count.should == 1
+  end
+  
+  it "should be able to trash a record and restore it with has_and_belongs_to_many associations" do
+    other_1 = NonTrashableTestModel.create(:name => 'one')
+    other_2 = NonTrashableTestModel.create(:name => 'two')
+    model = TrashableTestModel.new(:name => 'test')
+    model.non_trashable_test_models = [other_1, other_2]
+    model.save!
+    model.reload
+    ActsAsTrashable::TrashRecord.count.should == 0
+    NonTrashableTestModel.count.should == 2
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    TrashableTestModel.count.should == 0
+    NonTrashableTestModelsTrashableTestModel.count.should == 0
+    
+    restored = TrashableTestModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    restored.non_trashable_test_models.collect{|r| r.name}.sort.should == ['one', 'two']
+    ActsAsTrashable::TrashRecord.count.should == 0
+    TrashableTestModel.count.should == 1
+    NonTrashableTestModelsTrashableTestModel.count.should == 2
+  end
+  
+  it "should be able to trash a record and restore without associations" do
+    model = ActsAsTrashable::TrashableNamespaceModel.new
+    model.name = 'test'
+    model.save!
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    ActsAsTrashable::TrashableNamespaceModel.count.should == 0
+    
+    restored = ActsAsTrashable::TrashableNamespaceModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    ActsAsTrashable::TrashRecord.count.should == 0
+    ActsAsTrashable::TrashableNamespaceModel.count.should == 1
+  end
+  
+  it "should be able to trash a record and restore without associations" do
+    model = ActsAsTrashable::TrashableSubclassModel.new
+    model.name = 'test'
+    model.save!
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    model.destroy
+    ActsAsTrashable::TrashRecord.count.should == 1
+    ActsAsTrashable::TrashableSubclassModel.count.should == 0
+    
+    restored = ActsAsTrashable::TrashableSubclassModel.restore_trash!(model.id)
+    restored.reload
+    restored.name.should == 'test'
+    ActsAsTrashable::TrashRecord.count.should == 0
+    ActsAsTrashable::TrashableSubclassModel.count.should == 1
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require File.expand_path('../../lib/acts_as_trashable', __FILE__)
+require 'sqlite3'
+
+module ActsAsTrashable
+  module Test
+    def self.create_database
+      db_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp'))
+      Dir.mkdir(db_dir) unless File.exist?(db_dir)
+      db = File.join(db_dir, 'test.sqlite3')
+      ActiveRecord::Base.establish_connection("adapter" => "sqlite3", "database" => db)
+      ActsAsTrashable::TrashRecord.create_table
+    end
+
+    def self.delete_database
+      db_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'tmp'))
+      db = File.join(db_dir, 'test.sqlite3')
+      ActiveRecord::Base.connection.disconnect!
+      File.delete(db) if File.exist?(db)
+      Dir.delete(db_dir) if File.exist?(db_dir) and Dir.entries(db_dir).reject{|f| f.match(/^\.+$/)}.empty?
+    end
+  end
+end

data/spec/trash_record_spec.rb

@@ -0,0 +1,323 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'zlib'
+
+describe ActsAsTrashable::TrashRecord do
+  
+  class TestTrashableRecord
+    attr_accessor :attributes
+    
+    def initialize (attributes = {})
+      @attributes = attributes
+    end
+    
+    def self.reflections
+      @reflections || {}
+    end
+    
+    def self.reflections= (vals)
+      @reflections = vals
+    end
+  
+    def self.base_class
+      self
+    end
+    
+    def self.inheritance_column
+      'type'
+    end
+    
+    def id
+      attributes['id']
+    end
+    
+    def id= (val)
+      attributes['id'] = val
+    end
+    
+    def name= (val)
+      attributes['name'] = val
+    end
+    
+    def value= (val)
+      attributes['value'] = val
+    end
+  end
+  
+  class TestTrashableAssociationRecord < TestTrashableRecord
+    def self.reflections
+      @reflections || {}
+    end
+    
+    def self.reflections= (vals)
+      @reflections = vals
+    end
+  end
+  
+  class TestTrashableSubAssociationRecord < TestTrashableRecord
+    def self.reflections
+      @reflections || {}
+    end
+    
+    def self.reflections= (vals)
+      @reflections = vals
+    end
+  end
+  
+  before :all do
+    ActsAsTrashable::Test.create_database
+  end
+  
+  after :all do
+    ActsAsTrashable::Test.delete_database
+  end
+  
+  before :each do
+    TestTrashableRecord.reflections = nil
+    TestTrashableAssociationRecord.reflections = nil
+    TestTrashableSubAssociationRecord.reflections = nil
+  end
+  
+  it "should serialize all the attributes of the original model" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => 5}
+    original = TestTrashableRecord.new(attributes)
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.trashable_id.should == 1
+    trash.trashable_type.should == "TestTrashableRecord"
+    trash.trashable_attributes.should == attributes
+  end
+  
+  it "should be backward compatible with uncompressed data" do
+    attributes_1 = {'id' => 1, 'name' => 'trash', 'value' => 5}
+    attributes_2 = {'id' => 2, 'name' => 'trash2', 'value' => 10}
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new({}))
+    uncompressed = Marshal.dump(attributes_1)
+    compressed = Zlib::Deflate.deflate(Marshal.dump(attributes_2))
+    
+    trash.data = uncompressed
+    trash.trashable_attributes.should == attributes_1
+    trash.data = compressed
+    trash.trashable_attributes.should == attributes_2
+  end
+  
+  it "should serialize all the attributes of has_many associations with :dependent => :destroy" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => Time.now}
+    association_attributes_1 = {'id' => 2, 'name' => 'association_1'}
+    association_attributes_2 = {'id' => 3, 'name' => 'association_2'}
+    original = TestTrashableRecord.new(attributes)
+    dependent_associations = [TestTrashableAssociationRecord.new(association_attributes_1), TestTrashableAssociationRecord.new(association_attributes_2)]
+    dependent_associations_reflection = stub(:association, :name => :dependent_associations, :macro => :has_many, :options => {:dependent => :destroy})
+    non_dependent_associations_reflection = stub(:association, :name => :non_dependent_associations, :macro => :has_many, :options => {})
+    
+    TestTrashableRecord.reflections = {:dependent_associations => dependent_associations_reflection, :non_dependent_associations => non_dependent_associations_reflection}
+    original.should_not_receive(:non_dependent_associations)
+    original.should_receive(:dependent_associations).and_return(dependent_associations)
+    
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.trashable_attributes.should == attributes.merge(:dependent_associations => [association_attributes_1, association_attributes_2])
+  end
+  
+  it "should serialize all the attributes of has_one associations with :dependent => :destroy" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => Date.today}
+    association_attributes = {'id' => 2, 'name' => 'association_1'}
+    original = TestTrashableRecord.new(attributes)
+    dependent_association = TestTrashableAssociationRecord.new(association_attributes)
+    dependent_association_reflection = stub(:association, :name => :dependent_association, :macro => :has_one, :options => {:dependent => :destroy})
+    non_dependent_association_reflection = stub(:association, :name => :non_dependent_association, :macro => :has_one, :options => {})
+    
+    TestTrashableRecord.reflections = {:dependent_association => dependent_association_reflection, :non_dependent_association => non_dependent_association_reflection}
+    original.should_not_receive(:non_dependent_association)
+    original.should_receive(:dependent_association).and_return(dependent_association)
+    
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.trashable_attributes.should == attributes.merge(:dependent_association => association_attributes)
+  end
+  
+  it "should serialize all has_many_and_belongs_to_many associations" do
+    attributes = {'id' => 1, 'name' => 'trash'}
+    original = TestTrashableRecord.new(attributes)
+    association_reflection = stub(:association, :name => :associations, :macro => :has_and_belongs_to_many)
+    
+    TestTrashableRecord.reflections = {:dependent_association => association_reflection}
+    original.should_receive(:association_ids).and_return([2, 3, 4])
+    
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.trashable_attributes.should == attributes.merge(:associations => [2, 3, 4])
+  end
+  
+  it "should serialize associations with :dependent => :destroy of associations with :dependent => :destroy" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => Time.now}
+    association_attributes_1 = {'id' => 2, 'name' => 'association_1'}
+    association_attributes_2 = {'id' => 3, 'name' => 'association_2'}
+    original = TestTrashableRecord.new(attributes)
+    association_1 = TestTrashableAssociationRecord.new(association_attributes_1)
+    association_2 = TestTrashableAssociationRecord.new(association_attributes_2)
+    dependent_associations = [association_1, association_2]
+    dependent_associations_reflection = stub(:association, :name => :dependent_associations, :macro => :has_many, :options => {:dependent => :destroy})
+    sub_association_attributes = {'id' => 4, 'name' => 'sub_association_1'}
+    sub_association = TestTrashableSubAssociationRecord.new(sub_association_attributes)
+    sub_association_reflection = stub(:sub_association, :name => :sub_association, :macro => :has_one, :options => {:dependent => :destroy})
+    
+    TestTrashableRecord.reflections = {:dependent_associations => dependent_associations_reflection}
+    TestTrashableAssociationRecord.reflections = {:sub_association => sub_association_reflection}
+    original.should_receive(:dependent_associations).and_return(dependent_associations)
+    association_1.should_receive(:sub_association).and_return(sub_association)
+    association_2.should_receive(:sub_association).and_return(nil)
+    
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.trashable_attributes.should == attributes.merge(:dependent_associations => [association_attributes_1.merge(:sub_association => sub_association_attributes), association_attributes_2])
+  end
+  
+  it "should be able to restore the original model" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => 5}
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new(attributes))
+    trash.data = Zlib::Deflate.deflate(Marshal.dump(attributes))
+    restored = trash.restore
+    restored.class.should == TestTrashableRecord
+    restored.id.should == 1
+    restored.attributes.should == attributes
+  end
+  
+  it "should be able to restore associations" do
+    restored = TestTrashableRecord.new
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => Time.now, :associations => {'id' => 2, 'value' => 'val'}}
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new)
+    trash.data = Zlib::Deflate.deflate(Marshal.dump(attributes))
+    associations_reflection = stub(:associations, :name => :associations, :macro => :has_many, :options => {:dependent => :destroy})
+    TestTrashableRecord.reflections = {:associations => associations_reflection}
+    TestTrashableRecord.should_receive(:new).and_return(restored)
+    trash.should_receive(:restore_association).with(restored, :associations, {'id' => 2, 'value' => 'val'})
+    restored = trash.restore
+  end
+  
+  it "should be able to restore the has_many associations" do
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new)
+    record = TestTrashableRecord.new
+    
+    associations_reflection = stub(:associations, :name => :associations, :macro => :has_many, :options => {:dependent => :destroy})
+    TestTrashableRecord.reflections = {:associations => associations_reflection}
+    associations = mock(:associations)
+    record.should_receive(:associations).and_return(associations)
+    associated_record = TestTrashableAssociationRecord.new
+    associations.should_receive(:build).and_return(associated_record)
+    
+    trash.send(:restore_association, record, :associations, {'id' => 1, 'value' => 'val'})
+    associated_record.id.should == 1
+    associated_record.attributes.should == {'id' => 1, 'value' => 'val'}
+  end
+  
+  it "should be able to restore the has_one associations" do
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new)
+    record = TestTrashableRecord.new
+    
+    association_reflection = stub(:associations, :name => :association, :macro => :has_one, :klass => TestTrashableAssociationRecord, :options => {:dependent => :destroy})
+    TestTrashableRecord.reflections = {:association => association_reflection}
+    associated_record = TestTrashableAssociationRecord.new
+    TestTrashableAssociationRecord.should_receive(:new).and_return(associated_record)
+    record.should_receive(:association=).with(associated_record)
+    
+    trash.send(:restore_association, record, :association, {'id' => 1, 'value' => 'val'})
+    associated_record.id.should == 1
+    associated_record.attributes.should == {'id' => 1, 'value' => 'val'}
+  end
+  
+  it "should be able to restore the has_and_belongs_to_many associations" do
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new)
+    record = TestTrashableRecord.new
+    
+    associations_reflection = stub(:associations, :name => :associations, :macro => :has_and_belongs_to_many, :options => {})
+    TestTrashableRecord.reflections = {:associations => associations_reflection}
+    record.should_receive(:association_ids=).with([2, 3, 4])
+    
+    trash.send(:restore_association, record, :associations, [2, 3, 4])
+  end
+  
+  it "should be able to restore associations of associations" do
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new)
+    record = TestTrashableRecord.new
+    
+    associations_reflection = stub(:associations, :name => :associations, :macro => :has_many, :options => {:dependent => :destroy})
+    TestTrashableRecord.reflections = {:associations => associations_reflection}
+    associations = mock(:associations)
+    record.should_receive(:associations).and_return(associations)
+    associated_record = TestTrashableAssociationRecord.new
+    associations.should_receive(:build).and_return(associated_record)
+
+    sub_associated_record = TestTrashableSubAssociationRecord.new
+    TestTrashableAssociationRecord.should_receive(:new).and_return(sub_associated_record)
+    sub_association_reflection = stub(:sub_association, :name => :sub_association, :macro => :has_one, :klass => TestTrashableAssociationRecord, :options => {:dependent => :destroy})
+    TestTrashableAssociationRecord.reflections = {:sub_association => sub_association_reflection}
+    associated_record.should_receive(:sub_association=).with(sub_associated_record)
+    
+    trash.send(:restore_association, record, :associations, {'id' => 1, 'value' => 'val', :sub_association => {'id' => 2, 'value' => 'sub'}})
+    associated_record.id.should == 1
+    associated_record.attributes.should == {'id' => 1, 'value' => 'val'}
+    sub_associated_record.id.should == 2
+    sub_associated_record.attributes.should == {'id' => 2, 'value' => 'sub'}
+  end
+  
+  it "should be able to restore original model and save it" do
+    attributes = {'id' => 1, 'name' => 'trash', 'value' => 5}
+    original = TestTrashableRecord.new(attributes)
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    new_record = mock(:record)
+    new_record.should_receive(:save!)
+    trash.should_receive(:restore).and_return(new_record)
+    trash.should_receive(:destroy)
+    trash.restore!
+  end
+  
+  it "should be able to empty the trash by max age" do
+    max_age = mock(:max_age)
+    time = 1.day.ago
+    max_age.should_receive(:ago).and_return(time)
+    ActsAsTrashable::TrashRecord.should_receive(:delete_all).with(['created_at <= ?', time])
+    ActsAsTrashable::TrashRecord.empty_trash(max_age)
+  end
+  
+  it "should be able to empty the trash for only certain types" do
+    max_age = mock(:max_age)
+    time = 1.day.ago
+    max_age.should_receive(:ago).and_return(time)
+    mock_class_1 = stub(:class_1, :base_class => stub(:base_class_1, :name => 'TypeOne'))
+    mock_class_1.should_receive(:kind_of?).with(Class).and_return(true)
+    mock_class_2 = 'TypeTwo'
+    ActsAsTrashable::TrashRecord.should_receive(:delete_all).with(['created_at <= ? AND trashable_type IN (?, ?)', time, 'TypeOne', 'TypeTwo'])
+    ActsAsTrashable::TrashRecord.empty_trash(max_age, :only => [mock_class_1, mock_class_2])
+  end
+  
+  it "should be able to empty the trash for all except certain types" do
+    max_age = mock(:max_age)
+    time = 1.day.ago
+    max_age.should_receive(:ago).and_return(time)
+    ActsAsTrashable::TrashRecord.should_receive(:delete_all).with(['created_at <= ? AND trashable_type NOT IN (?)', time, 'TypeOne'])
+    ActsAsTrashable::TrashRecord.empty_trash(max_age, :except => :type_one)
+  end
+  
+  it "should be able to find a record by trashed type and id" do
+    trash = ActsAsTrashable::TrashRecord.new(TestTrashableRecord.new(:name => 'name'))
+    ActsAsTrashable::TrashRecord.should_receive(:find).with(:all, :conditions => {:trashable_type => 'TestTrashableRecord', :trashable_id => 1}).and_return([trash])
+    ActsAsTrashable::TrashRecord.find_trash(TestTrashableRecord, 1).should == trash
+  end
+  
+  it "should really save the trash record to the database and restore without any mocking" do
+    ActsAsTrashable::TrashRecord.empty_trash(0)
+    ActsAsTrashable::TrashRecord.count.should == 0
+    
+    attributes = {'id' => 1, 'name' => 'name value', 'value' => rand(1000000)}
+    original = TestTrashableRecord.new(attributes)
+    trash = ActsAsTrashable::TrashRecord.new(original)
+    trash.save!
+    ActsAsTrashable::TrashRecord.count.should == 1
+    
+    record = ActsAsTrashable::TrashRecord.find_trash(TestTrashableRecord, 1).restore
+    record.class.should == TestTrashableRecord
+    record.id.should == 1
+    record.attributes.should == attributes
+    
+    ActsAsTrashable::TrashRecord.empty_trash(0, :except => TestTrashableRecord)
+    ActsAsTrashable::TrashRecord.count.should == 1
+    ActsAsTrashable::TrashRecord.empty_trash(0, :only => TestTrashableRecord)
+    ActsAsTrashable::TrashRecord.count.should == 0
+  end
+  
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_trashable
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
+platform: ruby
+authors: 
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-22 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        version: "2.2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored. This is intended to reduce the risk of users misusing your application's delete function and losing data.
+email: brian@embellishedvisions.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- acts_as_trashable.gemspec
+- lib/acts_as_trashable.rb
+- lib/acts_as_trashable/trash_record.rb
+- spec/acts_as_trashable_spec.rb
+- spec/full_spec.rb
+- spec/spec_helper.rb
+- spec/trash_record_spec.rb
+has_rdoc: true
+homepage: http://github.com/bdurand/acts_as_trashable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ActiveRecord extension that serializes destroyed records into a trash table from which they can be restored.
+test_files: 
+- spec/acts_as_trashable_spec.rb
+- spec/full_spec.rb
+- spec/spec_helper.rb
+- spec/trash_record_spec.rb