delete_recursively 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd51a14780db543c8f623dcc7d65a1c64a0711c43e9f903b2dd2c1003290145
-  data.tar.gz: ccaac450fe4293eb267bc0570cc055b097bf78d7f179349a351798578c828e57
+  metadata.gz: ffee1566019b0d29f6ae829b45b0ff3ecef4fcbe05dca62d4dc592f6d3c4b13b
+  data.tar.gz: 3ee5fbef69a228c8195d4312d24df37ec742c91821598b89041bd002f5b79182
 SHA512:
-  metadata.gz: 604ba86881bd30346afa016ff584e1f94b8fa100ea5157e58750e3ff4fce9eb29ba24202b2c84ea1e3bcb0ddcfcac4abf0c5f60f093c6359bc121a952442dc87
-  data.tar.gz: 61307162f1cf6f673371d04c32d75b6c920a653254c6d54d3e6806abfc059336a17437b2bd523acd8669de0a9e77506275bb341cd88ce8e84221ee1486832f68
+  metadata.gz: ffaf462ba56e68682f10540b6e972017e5ded7da75d95644a74a1bd8b2dc962cf84c85aac2561bc3663e121c61731e9bfab497e8329417a4db7254e32fdaa4fa
+  data.tar.gz: 640d3df7bf66b5a7c1ba5a5a42d20f297de30f82e77644c85f6325746bb28a0e35c1c475dab375ac5013be838d14229d496475cd30ffa828f96d2ef20ed0d5a9

data/lib/delete_recursively/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeleteRecursively
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 end

data/lib/delete_recursively.rb

@@ -21,34 +21,78 @@ module DeleteRecursively
   # override Association#handle_dependency to apply the new option if it is set
   module DependencyHandling
     def handle_dependency
-      return super unless DeleteRecursively.enabled_for?(self)
+      if DeleteRecursively.enabled_for?(self)
+        delete_dependencies_recursively
+      else
+        super
+      end
+    end
+
+    def delete_dependencies_recursively(force: false)
       if reflection.belongs_to?
-        # can't use ::dependent_ids, owner is already destroyed at this point
-        ids = load_target ? target.id : []
+        # Special case. The owner is already destroyed at this point,
+        # so we cannot use the efficient ::dependent_ids lookup. Note that this
+        # only happens for a single entry-record on #destroy, though.
+        return unless target = load_target
+
+        DeleteRecursively.delete_records_recursively(target.class, target.id, force: force)
       else
-        ids = DeleteRecursively.dependent_ids(owner.class, owner.id, reflection)
+        DeleteRecursively.delete_recursively(reflection, owner.class, owner.id, force: force)
       end
-      DeleteRecursively.delete_recursively(reflection, ids)
     end
   end
 
   class << self
-    def delete_recursively(reflection, record_ids)
-      record_class = reflection.klass
-      if recurse_on?(reflection)
-        record_class.reflect_on_all_associations.each do |sub_reflection|
-          sub_ref_ids = dependent_ids(record_class, record_ids, sub_reflection)
-          delete_recursively(sub_reflection, sub_ref_ids)
+    def delete_recursively(reflection, owner_class, owner_ids, seen: [], force: false)
+      # Dependent deletion can be bi-directional, so we need to avoid a loop.
+      return if seen.include?(reflection)
+
+      seen << reflection
+
+      associated_classes(reflection).each do |record_class|
+        record_ids = nil # fetched only when needed for recursion, deletion, or both
+
+        if recurse_on?(reflection)
+          record_ids = dependent_ids(owner_class, owner_ids, reflection, record_class)
+          record_class.reflect_on_all_associations.each do |subref|
+            delete_recursively(subref, record_class, record_ids, seen: seen, force: force)
+          end
+        end
+
+        if dest_method = destructive_method(reflection, record_class, record_ids, force: force)
+          record_ids ||= dependent_ids(owner_class, owner_ids, reflection, record_class)
+          record_class.send(dest_method, record_ids)
+        end
+      end
+    end
+
+    def associated_classes(reflection)
+      if reflection.polymorphic?
+        # This ignores relatives where the inverse relation is not defined.
+        # The alternative to this approach would be to expensively select
+        # all distinct values from the *_type column:
+        # reflection.active_record.distinct.pluck(reflection.foreign_type)
+        ActiveRecord::Base.descendants.select do |klass|
+          klass.reflect_on_all_associations
+               .any? { |ref| ref.inverse_of == reflection }
         end
+      else
+        [reflection.klass]
       end
-      destroy_or_delete(reflection, record_class, record_ids)
     end
 
-    def destroy_or_delete(reflection, record_class, record_ids)
-      if destructive?(reflection)
-        record_class.destroy(record_ids)
-      elsif enabled_for?(reflection) || deleting?(reflection)
-        record_class.delete(record_ids)
+    def delete_records_recursively(record_class, record_ids, force: false)
+      record_class.reflect_on_all_associations.each do |ref|
+        delete_recursively(ref, record_class, record_ids, force: force)
+      end
+      record_class.delete(record_ids)
+    end
+
+    def destructive_method(reflection, record_class, record_ids, force: false)
+      if deleting?(reflection) || force && destructive?(reflection)
+        :delete
+      elsif destructive?(reflection)
+        :destroy
       end
     end
 
@@ -65,16 +109,19 @@ module DeleteRecursively
     end
 
     def deleting?(reflection)
-      %i[delete delete_all].include?(reflection.options[:dependent])
+      [:delete, :delete_all, NEW_DEPENDENT_OPTION].include?(reflection.options[:dependent])
     end
 
-    def dependent_ids(owner_class, owner_ids, reflection)
+    def dependent_ids(owner_class, owner_ids, reflection, assoc_class = nil)
       if reflection.belongs_to?
-        owners_arel = owner_class.where(owner_class.primary_key => owner_ids)
-        owners_arel.pluck(reflection.association_foreign_key).compact
+        owners = owner_class.where(owner_class.primary_key => owner_ids)
+        if reflection.polymorphic?
+          owners = owners.where(reflection.foreign_type => assoc_class.to_s)
+        end
+        owners.pluck(reflection.foreign_key).compact
       elsif reflection.through_reflection
         dependent_ids_with_through_option(owner_class, owner_ids, reflection)
-      else
+      else # plain `has_many` or `has_one`
         owner_foreign_key = foreign_key(owner_class, reflection)
         reflection.klass.where(owner_foreign_key => owner_ids).ids
       end
@@ -102,16 +149,21 @@ module DeleteRecursively
     end
 
     def foreign_key(owner_class, reflection)
-      custom_foreign_key = reflection && reflection.options[:foreign_key]
-      custom_foreign_key || owner_class.to_s.foreign_key
+      reflection && reflection.foreign_key || owner_class.to_s.foreign_key
     end
 
-    def all(record_class, criteria = {})
+    def all(record_class, criteria = {}, seen = [])
+      return if seen.include?(record_class)
+
+      seen << record_class
+
       record_class.reflect_on_all_associations.each do |reflection|
-        if recurse_on?(reflection)
-          all(reflection.klass, criteria)
-        elsif deleting?(reflection)
-          delete_with_applicable_criteria(reflection.klass, criteria)
+        associated_classes(reflection).each do |assoc_class|
+          if recurse_on?(reflection)
+            all(assoc_class, criteria, seen)
+          elsif deleting?(reflection)
+            delete_with_applicable_criteria(assoc_class, criteria)
+          end
         end
       end
       delete_with_applicable_criteria(record_class, criteria)
@@ -128,10 +180,26 @@ end
 
 require 'active_record'
 
-%w[BelongsTo HasMany HasOne].each do |assoc_name|
-  assoc_builder = ActiveRecord::Associations::Builder.const_get(assoc_name)
-  assoc_builder.singleton_class.prepend(DeleteRecursively::OptionPermission)
+module ActiveRecord
+  module Associations
+    %w[BelongsTo HasMany HasOne].each do |assoc_name|
+      assoc_builder = Builder.const_get(assoc_name)
+      assoc_builder.singleton_class.prepend(DeleteRecursively::OptionPermission)
 
-  assoc_class = ActiveRecord::Associations.const_get("#{assoc_name}Association")
-  assoc_class.prepend(DeleteRecursively::DependencyHandling)
+      assoc_class = const_get("#{assoc_name}Association")
+      assoc_class.prepend(DeleteRecursively::DependencyHandling)
+    end
+  end
+
+  class Base
+    def delete_recursively(force: false)
+      DeleteRecursively.delete_records_recursively(self.class, id, force: force)
+    end
+  end
+
+  class Relation
+    def delete_all_recursively(force: false)
+      DeleteRecursively.delete_records_recursively(klass, ids, force: force)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delete_recursively
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -162,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: Delete ActiveRecords efficiently