delete_recursively 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe5f313a4d9cd27cdbca3504b2d16966c1ed6623
-  data.tar.gz: 7e8c2c76945859371ffbb9c879524da9818adc27
+  metadata.gz: bd2146ffda7f8e2d85bd1855236af99dfb2c8e57
+  data.tar.gz: 3a854c4d3ed39014d7067992eb7d19a45e4adeff
 SHA512:
-  metadata.gz: c956f74f5e3609590015f894b385d467d2030193cae1dfdb4fc5c464d496cc5ec38c3815370fae123344473ab8a4be81dfd624ea122bcc65053b2965db9d17c4
-  data.tar.gz: bc23908040c1f20046e07a912a1841fb1e4c18902d12500927811971af31bbc6535779d67b87a0d972e6afd892397fdec0fe2fa2c2c64c13aa93dae7328949d2
+  metadata.gz: 834e49d0615645ed223225b17cdeeba1942afb985e8cadcb374c702d087fc95a3bbff438c707e44b5b011871faf8c957588b456653b38b82a3eb0eeb0176c2fd
+  data.tar.gz: 5f1d4fc60c57309329ea5686323553cf6738556175b06755346b860fa4faea1fea2928769349b301947acbae97b8ebd4e9e5cea1014ac8ba597b63d14eca743e

data/lib/delete_recursively.rb

@@ -7,55 +7,65 @@ module DeleteRecursively
   NEW_DEPENDENT_OPTION = :delete_recursively
 
   # override ::valid_dependent_options to make the new
-  # dependent option available to association builders
+  # dependent option available to Association::Builder classes
   module OptionPermission
     def valid_dependent_options
       super + [NEW_DEPENDENT_OPTION]
     end
   end
 
-  # override #handle_dependency to apply the new option if set
+  # override Association#handle_dependency to apply the new option if it is set
   module DependencyHandling
     def handle_dependency
-      super unless DeleteRecursively.enabled_for?(self)
-      # Pass true because #handle_dependency is triggered by destroy
-      # callbacks, and thus the owner is already being deleted.
-      DeleteRecursively.delete_recursively(owner.class, owner.id, true)
+      return super unless DeleteRecursively.enabled_for?(self)
+      if reflection.belongs_to?
+        # can't use ::dependent_ids, owner is already destroyed at this point
+        ids = load_target ? target.id : []
+      else
+        ids = DeleteRecursively.dependent_ids(owner.class, owner.id, reflection)
+      end
+      DeleteRecursively.delete_recursively(reflection, ids)
     end
   end
 
-  def self.enabled_for?(association)
-    association.options[:dependent] == NEW_DEPENDENT_OPTION
+  def self.delete_recursively(reflection, record_ids)
+    record_class = reflection.klass
+    record_class.reflect_on_all_associations.each do |sub_reflection|
+      next unless recurse_on?(sub_reflection)
+      dependent_ids = dependent_ids(record_class, record_ids, sub_reflection)
+      delete_recursively(sub_reflection, dependent_ids)
+    end
+    record_class.delete(record_ids) if enabled_for?(reflection)
+    record_class.destroy(record_ids) if destructive?(reflection)
   end
 
-  def self.delete_recursively(record_class, record_ids, only_dependents = false)
-    # delete all passed records
-    record_class.delete(record_ids) unless only_dependents
+  def self.recurse_on?(reflection)
+    enabled_for?(reflection) || destructive?(reflection)
+  end
 
-    # delete all records with a dependency on the passed records
-    record_class.reflect_on_all_associations.each do |assoc|
-      next unless enabled_for?(assoc)
-      dependent_class = assoc.klass
-      dependent_ids = dependent_ids(record_class, record_ids, assoc)
-      delete_recursively(dependent_class, dependent_ids)
-    end
+  def self.enabled_for?(reflection)
+    reflection.options[:dependent] == NEW_DEPENDENT_OPTION
+  end
+
+  def self.destructive?(reflection)
+    [:destroy, :destroy_all].include?(reflection.options[:dependent])
   end
 
-  def self.dependent_ids(record_class, record_ids, assoc)
-    if assoc.belongs_to?
-      records_arel = record_class.where(record_class.primary_key => record_ids)
-      records_arel.pluck(assoc.association_foreign_key).compact
+  def self.dependent_ids(owner_class, owner_ids, reflection)
+    if reflection.belongs_to?
+      owners_arel = owner_class.where(owner_class.primary_key => owner_ids)
+      owners_arel.pluck(reflection.association_foreign_key).compact
     else
-      custom_foreign_key = assoc.options[:foreign_key]
-      foreign_key = custom_foreign_key || record_class.to_s.foreign_key
-      assoc.klass.where(foreign_key => record_ids).ids
+      custom_foreign_key = reflection.options[:foreign_key]
+      foreign_key = custom_foreign_key || owner_class.to_s.foreign_key
+      reflection.klass.where(foreign_key => owner_ids).ids
     end
   end
 
   def self.all(record_class)
     record_class.delete_all
-    record_class.reflect_on_all_associations.each do |assoc|
-      all(assoc.klass) if enabled_for?(assoc)
+    record_class.reflect_on_all_associations.each do |reflection|
+      all(reflection.klass) if recurse_on?(reflection)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delete_recursively
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Janosch Müller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-30 00:00:00.000000000 Z
+date: 2015-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -136,8 +136,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Delete ActiveRecords efficiently
 test_files: []
+has_rdoc: