dependent-auto-rails 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f413fd93d4790779d9b0376755b188e1e62f5130bed767c0ff89dbb14a8a07cc
-  data.tar.gz: 34fdbdfc0246bc176827767b0273442edc4d49d64c3adbdefb2f11fc410aedee
+  metadata.gz: 4bace913fbaee41d6bd8330049633d641488b44e15d6881c8cb59c3e236e992d
+  data.tar.gz: 0c4d1c52f650c89d701df483e7e4fa430cf4c0ca4a77c6b5c14946a101d48591
 SHA512:
-  metadata.gz: 0f80bffdcfc4ad25719648bbdb3626e1a9e8c66b06819ff31c62eba80c260c71bf40bdf8b03eaf54132077caba29eaf9514d943bbf2c642dac319d6e96c6d187
-  data.tar.gz: 40801ab7610aaa5c837b0a1eeda0ef9591bcc87e70476c9bf3d1f632ad8be92f10f499a59d86dd25daab028b3f38a3b086657a6a4a52429c234ca1322824cf45
+  metadata.gz: 62a535b5da5d1f75c73a650b3505f0f5d51b60ce1b2b66bec050670b855f5756dd9bb8b6a9f559016366e834c0a8c8a5000f1330dba9ec87062e3dd7e801f204
+  data.tar.gz: aa0cabec1f5a7eebb977c85f9b98e30872c2e0c7acb8d7e6ec08ff642239bff43c5a153d8cec81ed0ca31d5e964d571eb98fd60f1a6fb6416c167d0b0bbca86c

data/CHANGELOG.md

@@ -1,5 +1,3 @@
-## [Unreleased]
-
-## [0.1.0] - 2024-02-18
+## [0.1.9] - 21/02/2024
 
 - Initial release

data/README.md

@@ -3,11 +3,13 @@
 
 # dependent-auto-rails
 
-This gem provides a new `dependent` option for ActiveRecord associations, `:auto`. Using this option will automatically select between `:destroy` and `:delete` / `:delete_all` during runtime based on whether or not the associated model has any destroy callbacks defined. This is useful since `dependent: :destroy` always initialises the associated records in order to execute their destroy callbacks regardless of whether or not there are any defined, but is often the go-to option since it is the safest. This can be expensive if there are many records to destroy.
+This gem provides a new `dependent` option for ActiveRecord associations, `:auto`. Using this option will automatically select between `:destroy` and `:delete` / `:delete_all` during runtime based on whether or not the associated model has any callbacks defined which would usually be executed as part of the destroy lifecycle. This is useful since `dependent: :destroy` always initialises the associated records in order to execute their callbacks regardless of whether or not there are any defined, but is often the go-to option since it is the safest. This can be expensive if there are many records to destroy.
 
 It is also useful since a model's associations are rarely updated, but it's business logic can change frequently. This means that if destroy callbacks are added or removed on the associated model, the `dependent` option on the parent model's association may need to be updated to reflect this. Using `dependent: :auto` will automatically select the appropriate `dependent` option based on the current state of the model.
 
-**NOTE**: The `:auto` option **ONLY** decides between `:destroy` and `:delete` / `:delete_all`. It does not support any other `dependent` option, such as:
+If you're looking for a solution with little less magic, check out https://github.com/gregnavis/active_record_doctor's `incorrect_dependent_option` detector.
+
+**NOTE**: The `:auto` option **ONLY** decides between `:destroy` and `:delete` / `:delete_all`. It does not use any of the other `dependent` options:
 - `:nullify`
 - `:destroy_async`
 - `:restrict_with_error`

data/lib/dependent-auto-rails/activerecord/reflection.rb

@@ -20,16 +20,16 @@ module ActiveRecord
           return super unless key == :dependent && super(:dependent) == :auto
 
           return @dependent_auto if defined?(@dependent_auto)
-          # The method returned here is only used for defining an after_commit callback
-          # for :destroy_async, so it doesn't really matter what we return here.
-          # This helps us cause we can't yet determine the correct method as
+          # The method returned here is only used to define an after_commit callback
+          # for :destroy_async, so it doesn't really matter what we return.
+          # This helps us since we can't yet determine the correct method as
           # the associated model might not have been evaluated.
           return fallback_method if defining_dependent_callbacks?
 
           @dependent_auto = begin
             model = super(:association_model_name).constantize
 
-            if model._destroy_callbacks.empty?
+            if executable_callbacks_on_destroy_for(model).empty?
               case super(:association_type)
               when :singular then :delete
               when :collection then :delete_all
@@ -43,13 +43,21 @@ module ActiveRecord
 
         private
 
-        def fallback_method
-          :destroy # The safest, also common to all supported associations
-        end
-
         def defining_dependent_callbacks?
           caller.any? { |line| line.include?("active_record/associations/builder/association.rb") }
         end
+
+        def executable_callbacks_on_destroy_for(model)
+          model._find_callbacks.to_a +
+            model._initialize_callbacks.to_a +
+            model._destroy_callbacks.to_a +
+            model._commit_callbacks.to_a +
+            model._rollback_callbacks.to_a
+        end
+
+        def fallback_method
+          :destroy # The safest, also common to all supported associations
+        end
       end
     end
 

data/lib/dependent-auto-rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DependentAutoRails
-  VERSION = "0.1.8"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dependent-auto-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Joshua Young
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-21 00:00:00.000000000 Z
+date: 2024-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord