permanent_records 2.0.0 → 2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gem 'activerecord'

data/README.markdown

@@ -54,7 +54,22 @@ And if you had dependent records that were set to be destroyed along with the pa
     # all the comments are destroyed as well
     User.find(3).revive
     # all the comments that were just destroyed are now back in pristine condition
+    
+    # forcing deletion works the same way: fi you hard delete a record, its dependent records will also be hard deleted
 
+## Can I use default scopes?
+
+In Rails 3, yes.
+
+    default_scope where(:deleted_at => nil)
+
+If you use such a default scope, you will need to simulate the `deleted` scope with a method
+
+    def self.deleted
+      self.unscoped.where('deleted_at IS NOT NULL')
+    end
+
+Rails 2 provides no practical means of overriding default scopes (aside from using something like `Model.with_exclusive_scope { find(id) }`), so you'll need to implement those yourself if you need them.
 
 Patches welcome, forks celebrated.
 

data/Rakefile

@@ -9,7 +9,7 @@ begin
     gem.description = %Q{Never Lose Data. Rather than deleting rows this sets Record#deleted_at and gives you all the scopes you need to work with your data.}
     gem.email = "gems@6brand.com"
     gem.homepage = "http://github.com/JackDanger/permanent_records"
-    gem.authors = ["Jack Danger Canty"]
+    gem.authors = ["Jack Danger Canty", "David Sulc"]
   end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.1.0

data/lib/permanent_records.rb

@@ -75,42 +75,60 @@ module PermanentRecords
     end
     
     def revive
-      # Rails 3
-      if ActiveRecord::VERSION::MAJOR >= 3
+      if active_record_3?
         _run_revive_callbacks do
           set_deleted_at nil
         end
       else
         run_callbacks :before_revive
+        attempt_notifying_observers(:before_revive)
         set_deleted_at nil
         run_callbacks :after_revive
+        attempt_notifying_observers(:after_revive)
       end
       self
     end
-    
-    def set_deleted_at(value)
-      return self unless is_permanent?
-      record = self.class.find(id)
-      record.update_attribute(:deleted_at, value)
-      @attributes, @attributes_cache = record.attributes, record.attributes
-    end
 
     def destroy(force = nil)
-      if ActiveRecord::VERSION::MAJOR >= 3
-        return super() unless is_permanent? && (:force != force)
+      if active_record_3?
+        unless is_permanent? && (:force != force)
+          return permanently_delete_records_after{ super() }
+        end
       end
       destroy_with_permanent_records force
     end
+    
+    private
+    def set_deleted_at(value)
+      return self unless is_permanent?
+      record = self.class
+      record = record.unscoped if active_record_3?
+      record = record.find(id)
+      record.deleted_at = value
+      begin
+        # we call save! instead of update_attribute so an ActiveRecord::RecordInvalid
+        # error will be raised if the record isn't valid. (This prevents reviving records that
+        # disregard validation constraints,)
+        record.save!
+        @attributes, @attributes_cache = record.attributes, record.attributes
+      rescue Exception => e
+        # trigger dependent record destruction (they were revived before this record,
+        # which cannot be revived due to validations)
+        record.destroy
+        raise e
+      end
+    end
 
     def destroy_with_permanent_records(force = nil)
-      if ActiveRecord::VERSION::MAJOR < 3
-        return destroy_without_permanent_records unless is_permanent? && (:force != force)
+      unless active_record_3?
+        unless is_permanent? && (:force != force)
+          return permanently_delete_records_after{ destroy_without_permanent_records }
+        end
       end
       unless deleted? || new_record?
         set_deleted_at Time.now
       end
-      # Rails 3
-      if ActiveRecord::VERSION::MAJOR >= 3
+      if active_record_3?
         _run_destroy_callbacks do
           save
         end
@@ -126,16 +144,29 @@ module PermanentRecords
       self.class.reflections.select do |name, reflection|
         'destroy' == reflection.options[:dependent].to_s && reflection.klass.is_permanent?
       end.each do |name, reflection|
-
-        send(name).find(:all,
-                        :conditions => [
-                          "#{reflection.quoted_table_name}.deleted_at > ?" +
-                          " AND " +
-                          "#{reflection.quoted_table_name}.deleted_at < ?",
-                          deleted_at - 3.seconds,
-                          deleted_at + 3.seconds
-                        ]
-                      ).each do |dependent|
+        cardinality = reflection.macro.to_s.gsub('has_', '')
+        if cardinality == 'many'
+          records = send(name)
+          records = records.unscoped if active_record_3?
+          records = records.find(:all,
+            :conditions => [
+              "#{reflection.quoted_table_name}.deleted_at > ?" +
+              " AND " +
+              "#{reflection.quoted_table_name}.deleted_at < ?",
+              deleted_at - 3.seconds,
+              deleted_at + 3.seconds
+            ]
+          )
+        elsif cardinality == 'one'
+          if active_record_3?
+            self.class.unscoped do
+              records = [] << send(name)
+            end
+          else
+            records = [] << send(name)
+          end
+        end
+        records.compact.each do |dependent|
           dependent.revive
         end
 
@@ -143,6 +174,71 @@ module PermanentRecords
         send(name, :reload)
       end
     end
+    
+    def attempt_notifying_observers(callback)
+      begin
+        notify_observers(callback)
+      rescue NoMethodError => e
+        # do nothing: this model isn't being observed
+      end
+    end
+    
+    # return the records corresponding to an association with the `:dependent => :destroy` option
+    def get_dependent_records
+      dependent_records = {}
+      
+      # check which dependent records are to be destroyed
+      klass = self.class
+      klass.reflections.each do |key, reflection|
+        if reflection.options[:dependent] == :destroy
+          next unless records = self.send(key) # skip if there are no dependent record instances
+          if records.respond_to? :size
+            next unless records.size > 0 # skip if there are no dependent record instances
+          else
+            records = [] << records
+          end
+          dependent_record = records.first
+          next if dependent_record.nil?
+          dependent_records[dependent_record.class] = records.map(&:id)
+        end
+      end
+      dependent_records
+    end
+    
+    # If we force the destruction of the record, we will need to force the destruction of dependent records if the
+    # user specified `:dependent => :destroy` in the model.
+    # By default, the call to super/destroy_with_permanent_records (i.e. the &block param) will only soft delete 
+    # the dependent records; we keep track of the dependent records
+    # that have `:dependent => :destroy` and call destroy(force) on them after the call to super
+    def permanently_delete_records_after(&block)
+      dependent_records = get_dependent_records
+      result = block.call
+      if result
+        permanently_delete_records(dependent_records)
+      end
+      result
+    end
+    
+    # permanently delete the records (i.e. remove from database)
+    def permanently_delete_records(dependent_records)
+      dependent_records.each do |klass, ids|
+        ids.each do |id|
+          begin
+            record = klass
+            record = record.unscoped if active_record_3?
+            record = record.find(id)
+          rescue ActiveRecord::RecordNotFound
+            next # the record has already been deleted, possibly due to another association with `:dependent => :destroy`
+          end
+          record.deleted_at = nil
+          record.destroy(:force)
+        end
+      end
+    end
+    
+    def active_record_3?
+      ActiveRecord::VERSION::MAJOR >= 3
+    end
   end
 end
 

data/permanent_records.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{permanent_records}
-  s.version = "2.0.0"
+  s.version = "2.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jack Danger Canty"]
-  s.date = %q{2011-04-10}
+  s.authors = ["Jack Danger Canty", "David Sulc"]
+  s.date = %q{2011-06-06}
   s.description = %q{Never Lose Data. Rather than deleting rows this sets Record#deleted_at and gives you all the scopes you need to work with your data.}
   s.email = %q{gems@6brand.com}
   s.extra_rdoc_files = [
@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    "Gemfile",
     "LICENSE",
     "MIT-LICENSE",
     "README.markdown",
@@ -27,37 +28,35 @@ Gem::Specification.new do |s|
     "install.rb",
     "lib/permanent_records.rb",
     "permanent_records.gemspec",
+    "test/comment.rb",
     "test/database.yml",
+    "test/difficulty.rb",
     "test/hole.rb",
     "test/kitty.rb",
+    "test/location.rb",
     "test/mole.rb",
     "test/muskrat.rb",
     "test/permanent_records_test.rb",
     "test/schema.rb",
     "test/test_helper.rb",
+    "test/unused_model.rb",
     "uninstall.rb"
   ]
   s.homepage = %q{http://github.com/JackDanger/permanent_records}
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.4.2}
   s.summary = %q{Soft-delete your ActiveRecord records}
-  s.test_files = [
-    "test/hole.rb",
-    "test/kitty.rb",
-    "test/mole.rb",
-    "test/muskrat.rb",
-    "test/permanent_records_test.rb",
-    "test/schema.rb",
-    "test/test_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
     else
+      s.add_dependency(%q<activerecord>, [">= 0"])
     end
   else
+    s.add_dependency(%q<activerecord>, [">= 0"])
   end
 end
 

data/test/comment.rb

@@ -0,0 +1,11 @@
+class Comment < ActiveRecord::Base
+  belongs_to :hole
+  
+  if ActiveRecord::VERSION::MAJOR >= 3
+    default_scope where(:deleted_at => nil)
+  else
+    def self.unscoped
+      self
+    end
+  end
+end

data/test/difficulty.rb

@@ -0,0 +1,11 @@
+class Difficulty < ActiveRecord::Base
+  belongs_to :hole
+  
+  if ActiveRecord::VERSION::MAJOR >= 3
+    default_scope where(:deleted_at => nil)
+  else
+    def self.unscoped
+      self
+    end
+  end
+end

data/test/hole.rb

@@ -3,4 +3,9 @@ class Hole < ActiveRecord::Base
   has_many :muskrats, :dependent => :destroy
   # moles are not permanent
   has_many :moles, :dependent => :destroy
+  
+  has_one :location, :dependent => :destroy
+  has_one :unused_model, :dependent => :destroy
+  has_one :difficulty, :dependent => :destroy
+  has_many :comments, :dependent => :destroy
 end

data/test/location.rb

@@ -0,0 +1,5 @@
+class Location < ActiveRecord::Base
+  belongs_to :hole
+  
+  validates_uniqueness_of :name, :scope => :deleted_at
+end

data/test/permanent_records_test.rb

@@ -1,6 +1,11 @@
+# note: functionality to deal with default scopes (and the `unscoped` scope) has been added (and will be tested) for Rails 3
+# this default scope functionality is skipped for Rails 2, because Rails 2 provides no functional means of altering the default scope
+# in particular, setting the default scope in Rails 3 to ignore soft deleted records will work properly, whereas in Rails 2, it will
+# lead to a world of pain
+
 require File.expand_path(File.dirname(__FILE__) + "/test_helper")
 
-%w(hole mole muskrat kitty).each do |a|
+%w(hole mole muskrat kitty location comment difficulty unused_model).each do |a|
   require File.expand_path(File.dirname(__FILE__) + "/" + a)
 end
 
@@ -17,7 +22,28 @@ class PermanentRecordsTest < ActiveSupport::TestCase
     @hole = Hole.create(:number => 14)
     @hole.muskrats.create(:name => "Active Muskrat")
     @hole.muskrats.create(:name => "Deleted Muskrat", :deleted_at => 5.days.ago)
+    Location.delete_all
+    @location = Location.create(:name => "South wall")
+    @hole.location = @location
+    @hole.save!
     @mole = @hole.moles.create(:name => "Grabowski")
+    
+    if ActiveRecord::VERSION::MAJOR >= 3
+      Difficulty.unscoped.delete_all
+      Comment.unscoped.delete_all
+    else
+      Difficulty.delete_all
+      Comment.delete_all
+    end
+    # test has_one cardinality with model having a default scope
+    @hole_with_difficulty = Hole.create(:number => 16)
+    @hole_with_difficulty.difficulty = Difficulty.create!(:name => 'Hard')
+    @hole_with_difficulty.save!
+    
+    # test has_many cardinality with model having a default scope
+    @hole_with_comments = Hole.create(:number => 16)
+    @hole_with_comments.comments << Comment.create!(:text => "Beware of the pond.")
+    @hole_with_comments.comments << Comment.create!(:text => "Muskrats live here.")
   end
   
   def teardown
@@ -109,7 +135,7 @@ class PermanentRecordsTest < ActiveSupport::TestCase
     end
   end
   
-  def test_dependent_permanent_records_should_be_marked_as_deleted
+  def test_dependent_permanent_records_with_has_many_cardinality_should_be_marked_as_deleted
     assert @hole.is_permanent?
     assert @hole.muskrats.first.is_permanent?
     assert_no_difference "Muskrat.count" do
@@ -118,7 +144,17 @@ class PermanentRecordsTest < ActiveSupport::TestCase
     assert @hole.muskrats.first.deleted?
   end
   
-  def test_dependent_permanent_records_should_be_revived_when_parent_is_revived
+  def test_dependent_permanent_records_with_has_one_cardinality_should_be_marked_as_deleted
+    assert @hole.is_permanent?
+    assert @hole.location.is_permanent?
+    assert_no_difference "Location.count" do
+      @hole.destroy
+    end
+    assert @hole.location.deleted?
+    assert Location.find_by_name("South wall").deleted?
+  end
+  
+  def test_dependent_permanent_records_with_has_many_cardinality_should_be_revived_when_parent_is_revived
     assert @hole.is_permanent?
     @hole.destroy
     assert @hole.muskrats.find_by_name("Active Muskrat").deleted?
@@ -126,6 +162,49 @@ class PermanentRecordsTest < ActiveSupport::TestCase
     assert !@hole.muskrats.find_by_name("Active Muskrat").deleted?
   end
   
+  def test_dependent_permanent_records_with_has_one_cardinality_should_be_revived_when_parent_is_revived
+    assert @hole.is_permanent?
+    @hole.destroy
+    assert Location.find_by_name("South wall").deleted?
+    @hole.revive
+    assert !Location.find_by_name("South wall").deleted?
+  end
+  
+  # see comment at top of file for reasoning behind conditional testing of default scope
+  if ActiveRecord::VERSION::MAJOR >= 3
+    def test_dependent_permanent_records_with_has_one_cardinality_and_default_scope_should_be_revived_when_parent_is_revived
+      assert @hole_with_difficulty.is_permanent?
+      assert_difference("Difficulty.count", -1) do
+        @hole_with_difficulty.destroy
+      end
+      assert_nil Difficulty.find_by_name("Hard")
+      assert Difficulty.unscoped.find_by_name("Hard").deleted?
+      @hole_with_difficulty.revive
+      assert_not_nil Difficulty.find_by_name("Hard")
+      assert !Difficulty.unscoped.find_by_name("Hard").deleted?
+    end
+    
+    def test_dependent_permanent_records_with_has_many_cardinality_and_default_scope_should_be_revived_when_parent_is_revived
+      assert @hole_with_comments.is_permanent?
+      assert_difference("Comment.count", -2) do
+        @hole_with_comments.destroy
+      end
+      assert_nil Comment.find_by_text("Beware of the pond.")
+      assert Comment.unscoped.find_by_text("Beware of the pond.").deleted?
+      @hole_with_comments.revive
+      assert_not_nil Comment.find_by_text("Beware of the pond.")
+      assert !Comment.unscoped.find_by_text("Beware of the pond.").deleted?
+    end
+  end
+  
+  def test_inexistent_dependent_models_should_not_cause_errors
+    hole_with_unused_model = Hole.create!(:number => 1)
+    hole_with_unused_model.destroy
+    assert_nothing_raised do
+      hole_with_unused_model.revive
+    end
+  end
+  
   def test_old_dependent_permanent_records_should_not_be_revived
     assert @hole.is_permanent?
     @hole.destroy
@@ -133,4 +212,46 @@ class PermanentRecordsTest < ActiveSupport::TestCase
     @hole.revive
     assert @hole.muskrats.find_by_name("Deleted Muskrat").deleted?
   end
+  
+  def test_validate_records_before_revival
+    duplicate_location = Location.new(@location.attributes)
+    @location.destroy
+    @location.reload
+    duplicate_location.save!
+    assert_equal duplicate_location.name, @location.name
+    assert_no_difference('Location.not_deleted.count') do
+      assert_raise (ActiveRecord::RecordInvalid) do
+        @location.revive
+      end
+    end
+  end
+  
+  def test_force_deleting_a_record_with_has_one_force_deletes_dependent_records
+    hole = Hole.create(:number => 1)
+    location = Location.create(:name => "Near the clubhouse")
+    hole.location = location
+    hole.save!
+    
+    assert_difference(monitor_for('Hole'), -1) do
+      assert_difference(monitor_for('Location'), -1) do
+        hole.destroy(:force)
+      end
+    end
+  end
+  
+  def test_force_deleting_a_record_with_has_many_force_deletes_dependent_records
+    assert_difference(monitor_for('Hole'), -1) do
+      assert_difference(monitor_for('Comment'), -2) do
+        @hole_with_comments.destroy(:force)
+      end
+    end
+  end
+  
+  def test_force_deletign_with_multiple_associations
+    assert_difference(monitor_for('Muskrat'), -2) do
+      assert_difference(monitor_for('Mole'), -1) do
+        @hole.destroy(:force)
+      end
+    end
+  end
 end

data/test/schema.rb

@@ -19,5 +19,29 @@ ActiveRecord::Schema.define(:version => 1) do
     t.string :name
     t.references :hole
   end
+  
+  create_table :locations, :force => true do |t|
+    t.string :name
+    t.references :hole
+    t.datetime :deleted_at
+  end
+  
+  create_table :comments, :force => true do |t|
+    t.string :text
+    t.references :hole
+    t.datetime :deleted_at
+  end
+  
+  create_table :difficulties, :force => true do |t|
+    t.string :name
+    t.references :hole
+    t.datetime :deleted_at
+  end
+  
+  create_table :unused_models, :force => true do |t|
+    t.string :name
+    t.references :hole
+    t.datetime :deleted_at
+  end
 
 end

data/test/test_helper.rb

@@ -37,4 +37,9 @@ class ActiveSupport::TestCase #:nodoc:
   self.use_instantiated_fixtures  = false
 
   # Add more helper methods to be used by all tests here...
+  def monitor_for(class_name)
+    result = class_name
+    result += '.unscoped' if ActiveRecord::VERSION::MAJOR >= 3
+    result += '.count'
+  end
 end

data/test/unused_model.rb

@@ -0,0 +1,2 @@
+class UnusedModel < ActiveRecord::Base
+end

metadata

@@ -1,24 +1,38 @@
 --- !ruby/object:Gem::Specification 
 name: permanent_records
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 2
+  - 1
   - 0
-  - 0
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Jack Danger Canty
+- David Sulc
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-04-30 00:00:00 -07:00
+date: 2011-06-06 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  prerelease: false
+  name: activerecord
 description: Never Lose Data. Rather than deleting rows this sets Record#deleted_at and gives you all the scopes you need to work with your data.
 email: gems@6brand.com
 executables: []
@@ -30,6 +44,7 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - .document
+- Gemfile
 - LICENSE
 - MIT-LICENSE
 - README.markdown
@@ -39,14 +54,18 @@ files:
 - install.rb
 - lib/permanent_records.rb
 - permanent_records.gemspec
+- test/comment.rb
 - test/database.yml
+- test/difficulty.rb
 - test/hole.rb
 - test/kitty.rb
+- test/location.rb
 - test/mole.rb
 - test/muskrat.rb
 - test/permanent_records_test.rb
 - test/schema.rb
 - test/test_helper.rb
+- test/unused_model.rb
 - uninstall.rb
 has_rdoc: true
 homepage: http://github.com/JackDanger/permanent_records
@@ -82,11 +101,5 @@ rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: Soft-delete your ActiveRecord records
-test_files: 
-- test/hole.rb
-- test/kitty.rb
-- test/mole.rb
-- test/muskrat.rb
-- test/permanent_records_test.rb
-- test/schema.rb
-- test/test_helper.rb
+test_files: []
+