delete_recursively 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffee1566019b0d29f6ae829b45b0ff3ecef4fcbe05dca62d4dc592f6d3c4b13b
-  data.tar.gz: 3ee5fbef69a228c8195d4312d24df37ec742c91821598b89041bd002f5b79182
+  metadata.gz: b030ca2cd0433b8f6edbe713ec5e75651cfd8b17b09ce8080c0fe9867b85799d
+  data.tar.gz: db4adfc88b256876c756cd7f216192b324c4c2a56892c57e00961d19c8121fea
 SHA512:
-  metadata.gz: ffaf462ba56e68682f10540b6e972017e5ded7da75d95644a74a1bd8b2dc962cf84c85aac2561bc3663e121c61731e9bfab497e8329417a4db7254e32fdaa4fa
-  data.tar.gz: 640d3df7bf66b5a7c1ba5a5a42d20f297de30f82e77644c85f6325746bb28a0e35c1c475dab375ac5013be838d14229d496475cd30ffa828f96d2ef20ed0d5a9
+  metadata.gz: 90ec72416540144c258e6234142d9877596e3e42d17489d539b80ddaa1fe7cf80d2a5adb19269e4e3759393c83527edd994468fb220611a9a3752da4d37018c1
+  data.tar.gz: f4f0e2432412bf80ca7275d5fe43e03317643e35d6d1bae4cf890057915c90dc57cb682066366c5fe9d51f2a1e2c086810cad9c3e65e1f55561727f4ccdaf802

data/lib/delete_recursively/active_record_extensions.rb

@@ -0,0 +1,57 @@
+# override ::valid_dependent_options to make the new
+# dependent option available to Association::Builder classes
+module DeleteRecursively::OptionPermission
+  def valid_dependent_options
+    super + [DeleteRecursively::NEW_DEPENDENT_OPTION]
+  end
+end
+
+# override Association#handle_dependency to apply the new option if it is set
+module DeleteRecursively::DependencyHandling
+  def handle_dependency
+    if DeleteRecursively.enabled_for?(self)
+      delete_dependencies_recursively
+    else
+      super
+    end
+  end
+
+  def delete_dependencies_recursively(force: false)
+    if reflection.belongs_to?
+      # 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
+      DeleteRecursively.delete_recursively(reflection, nil, owner.id, force: force)
+    end
+  end
+end
+
+require 'active_record'
+
+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 = 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

data/lib/delete_recursively/associated_class_finder.rb

@@ -0,0 +1,57 @@
+module DeleteRecursively::AssociatedClassFinder
+  class << self
+    def call(reflection)
+      cache[reflection] ||= find_classes(reflection)
+    end
+
+    def clear_cache
+      cache.clear
+    end
+
+    private
+
+    def cache
+      @cache ||= {}.tap(&:compare_by_identity)
+    end
+
+    def find_classes(reflection)
+      result =
+        if reflection.polymorphic?
+          find_classes_for_polymorphic_reflection(reflection)
+        else
+          [reflection.klass]
+        end.compact
+
+      result.empty? && warn_empty_result(reflection)
+
+      result
+    end
+
+    # 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)
+    def find_classes_for_polymorphic_reflection(reflection)
+      ActiveRecord::Base.descendants.select do |klass|
+        klass.reflect_on_all_associations.any? do |other_ref|
+          next other_ref.inverse_of == reflection unless other_ref.polymorphic?
+
+          # check if its a bi-directional polymorphic association
+          begin
+            other_ref.polymorphic_inverse_of(reflection.active_record)
+          rescue ActiveRecord::InverseOfAssociationNotFoundError
+            next
+          end
+        end
+      end
+    end
+
+    def warn_empty_result(reflection)
+      warn "#{self} could not find associated class(es) for "\
+           "#{reflection.active_record}##{reflection.name}. "\
+           "You might need to define the inverse association(s) or, "\
+           "if they are already defined, add `as :#{reflection.name}` or "\
+           "`inverse_of :#{reflection.name}` to them."
+    end
+  end
+end

data/lib/delete_recursively/dependent_id_finder.rb

@@ -0,0 +1,47 @@
+module DeleteRecursively::DependentIdFinder
+  class << self
+    def call(owner_ids, reflection, assoc_class)
+      owner_class = reflection.active_record
+
+      if reflection.belongs_to?
+        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_ids, reflection)
+      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
+    end
+
+    private
+
+    def dependent_ids_with_through_option(owner_ids, reflection)
+      through_reflection = reflection.through_reflection
+      owner_foreign_key = foreign_key(reflection.active_record, through_reflection)
+
+      dependent_class = reflection.klass
+      dependent_through_reflection = inverse_through_reflection(reflection)
+      dependent_foreign_key =
+        foreign_key(dependent_class, dependent_through_reflection)
+
+      through_reflection.klass
+                        .where(owner_foreign_key => owner_ids)
+                        .pluck(dependent_foreign_key)
+    end
+
+    def foreign_key(owner_class, reflection)
+      reflection && reflection.foreign_key || owner_class.to_s.foreign_key
+    end
+
+    def inverse_through_reflection(reflection)
+      through_class = reflection.through_reflection.klass
+      reflection.klass.reflect_on_all_associations
+                .map(&:through_reflection)
+                .find { |thr_ref| thr_ref && thr_ref.klass == through_class }
+    end
+  end
+end

data/lib/delete_recursively/railtie.rb

@@ -0,0 +1,5 @@
+class DeleteRecursively::Railtie < ::Rails::Railtie
+  config.to_prepare do
+    DeleteRecursively::AssociatedClassFinder.clear_cache
+  end
+end

data/lib/delete_recursively/version.rb

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

data/lib/delete_recursively.rb

@@ -6,159 +6,59 @@
 # Adds a new dependent: option to ActiveRecord associations.
 #
 module DeleteRecursively
-  require_relative File.join('delete_recursively', 'version')
-
   NEW_DEPENDENT_OPTION = :delete_recursively
 
-  # override ::valid_dependent_options to make the new
-  # dependent option available to Association::Builder classes
-  module OptionPermission
-    def valid_dependent_options
-      super + [NEW_DEPENDENT_OPTION]
-    end
-  end
-
-  # override Association#handle_dependency to apply the new option if it is set
-  module DependencyHandling
-    def handle_dependency
-      if DeleteRecursively.enabled_for?(self)
-        delete_dependencies_recursively
-      else
-        super
-      end
-    end
-
-    def delete_dependencies_recursively(force: false)
-      if reflection.belongs_to?
-        # 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
-        DeleteRecursively.delete_recursively(reflection, owner.class, owner.id, force: force)
-      end
-    end
-  end
+  require_relative File.join('delete_recursively', 'active_record_extensions')
+  require_relative File.join('delete_recursively', 'associated_class_finder')
+  require_relative File.join('delete_recursively', 'dependent_id_finder')
+  require_relative File.join('delete_recursively', 'railtie') if defined?(::Rails::Railtie)
+  require_relative File.join('delete_recursively', 'version')
 
   class << self
-    def delete_recursively(reflection, owner_class, owner_ids, seen: [], force: false)
+    def delete_recursively(reflection, _legacy_arg, owner_ids, seen: [], force: false)
+      owner_ids = Array(owner_ids)
+      return if owner_ids.empty?
+
       # Dependent deletion can be bi-directional, so we need to avoid a loop.
-      return if seen.include?(reflection)
+      # Note, however, that an association could be reached multiple times, from
+      # different starting points within the association tree, and having
+      # different owner_ids. In this case, we do need to go through it again.
+      recursion_identifier = [reflection, owner_ids]
+      return if seen.include?(recursion_identifier)
 
-      seen << reflection
+      seen << recursion_identifier
 
-      associated_classes(reflection).each do |record_class|
+      AssociatedClassFinder.call(reflection).each do |assoc_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)
+          record_ids = DependentIdFinder.call(owner_ids, reflection, assoc_class)
+          assoc_class.reflect_on_all_associations.each do |subref|
+            delete_recursively(subref, nil, 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)
+        if dest_method = destructive_method(reflection, force: force)
+          record_ids ||= DependentIdFinder.call(owner_ids, reflection, assoc_class)
+          assoc_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
-    end
-
     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)
+        delete_recursively(ref, nil, 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
-
-    def recurse_on?(reflection)
-      enabled_for?(reflection) || destructive?(reflection)
-    end
-
-    def enabled_for?(reflection)
-      reflection.options[:dependent] == NEW_DEPENDENT_OPTION
-    end
-
-    def destructive?(reflection)
-      %i[destroy destroy_all].include?(reflection.options[:dependent])
-    end
-
-    def deleting?(reflection)
-      [:delete, :delete_all, NEW_DEPENDENT_OPTION].include?(reflection.options[:dependent])
-    end
-
-    def dependent_ids(owner_class, owner_ids, reflection, assoc_class = nil)
-      if reflection.belongs_to?
-        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 # plain `has_many` or `has_one`
-        owner_foreign_key = foreign_key(owner_class, reflection)
-        reflection.klass.where(owner_foreign_key => owner_ids).ids
-      end
-    end
-
-    def dependent_ids_with_through_option(owner_class, owner_ids, reflection)
-      through_reflection = reflection.through_reflection
-      owner_foreign_key = foreign_key(owner_class, through_reflection)
-
-      dependent_class = reflection.klass
-      dependent_through_reflection = inverse_through_reflection(reflection)
-      dependent_foreign_key =
-        foreign_key(dependent_class, dependent_through_reflection)
-
-      through_reflection.klass
-                        .where(owner_foreign_key => owner_ids)
-                        .pluck(dependent_foreign_key)
-    end
-
-    def inverse_through_reflection(reflection)
-      through_class = reflection.through_reflection.klass
-      reflection.klass.reflect_on_all_associations
-                .map(&:through_reflection)
-                .find { |thr_ref| thr_ref && thr_ref.klass == through_class }
-    end
-
-    def foreign_key(owner_class, reflection)
-      reflection && reflection.foreign_key || owner_class.to_s.foreign_key
-    end
-
     def all(record_class, criteria = {}, seen = [])
       return if seen.include?(record_class)
 
       seen << record_class
 
       record_class.reflect_on_all_associations.each do |reflection|
-        associated_classes(reflection).each do |assoc_class|
+        AssociatedClassFinder.call(reflection).each do |assoc_class|
           if recurse_on?(reflection)
             all(assoc_class, criteria, seen)
           elsif deleting?(reflection)
@@ -166,40 +66,41 @@ module DeleteRecursively
           end
         end
       end
+
       delete_with_applicable_criteria(record_class, criteria)
     end
 
+    def enabled_for?(reflection)
+      reflection.options[:dependent] == NEW_DEPENDENT_OPTION
+    end
+
+    private
+
     def delete_with_applicable_criteria(record_class, criteria)
       applicable_criteria = criteria.select do |column_name, _value|
         record_class.column_names.include?(column_name.to_s)
       end
       record_class.where(applicable_criteria).delete_all
     end
-  end
-end
-
-require 'active_record'
 
-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)
+    def recurse_on?(reflection)
+      enabled_for?(reflection) || destructive?(reflection)
+    end
 
-      assoc_class = const_get("#{assoc_name}Association")
-      assoc_class.prepend(DeleteRecursively::DependencyHandling)
+    def destructive?(reflection)
+      %i[destroy destroy_all].include?(reflection.options[:dependent])
     end
-  end
 
-  class Base
-    def delete_recursively(force: false)
-      DeleteRecursively.delete_records_recursively(self.class, id, force: force)
+    def deleting?(reflection)
+      [:delete, :delete_all, NEW_DEPENDENT_OPTION].include?(reflection.options[:dependent])
     end
-  end
 
-  class Relation
-    def delete_all_recursively(force: false)
-      DeleteRecursively.delete_records_recursively(klass, ids, force: force)
+    def destructive_method(reflection, force: false)
+      if deleting?(reflection) || force && destructive?(reflection)
+        :delete
+      elsif destructive?(reflection)
+        :destroy
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delete_recursively
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-29 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -36,14 +36,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: codecov
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +142,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/delete_recursively.rb
+- lib/delete_recursively/active_record_extensions.rb
+- lib/delete_recursively/associated_class_finder.rb
+- lib/delete_recursively/dependent_id_finder.rb
+- lib/delete_recursively/railtie.rb
 - lib/delete_recursively/version.rb
 homepage: https://github.com/jaynetics/delete_recursively
 licenses:
@@ -162,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Delete ActiveRecords efficiently