dependent-auto-rails 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a862d80808c8cc6d619f6c5d2b2b2eb064a54f1382ee27a806f81608e5d83165
-  data.tar.gz: e6c078c89f423af15585de3a697688fb314aa24ffb3995005f479cb2c6ac4650
+  metadata.gz: f413fd93d4790779d9b0376755b188e1e62f5130bed767c0ff89dbb14a8a07cc
+  data.tar.gz: 34fdbdfc0246bc176827767b0273442edc4d49d64c3adbdefb2f11fc410aedee
 SHA512:
-  metadata.gz: bee37a9ce116600e8458bd1af1580011e0fd91ea9f2cf70eb91b5e62ce9f3ab353cce542e0d6f8ce3fd973aaea70149df915a4411f5d47841a728cd6ac4de988
-  data.tar.gz: 6aceba442aae030f9eeebb8735623a89823b018ddf531ffcde1c9d179fffbe1b4b892bd8c2b046eccc20a819018c4fddcf3904089cf0de30512959958d239354
+  metadata.gz: 0f80bffdcfc4ad25719648bbdb3626e1a9e8c66b06819ff31c62eba80c260c71bf40bdf8b03eaf54132077caba29eaf9514d943bbf2c642dac319d6e96c6d187
+  data.tar.gz: 40801ab7610aaa5c837b0a1eeda0ef9591bcc87e70476c9bf3d1f632ad8be92f10f499a59d86dd25daab028b3f38a3b086657a6a4a52429c234ca1322824cf45

data/README.md

@@ -1,10 +1,13 @@
+[![Version](https://img.shields.io/gem/v/dependent-auto-rails)][badges:0-gem]
+[![Build](https://img.shields.io/github/actions/workflow/status/joshuay03/dependent-auto-rails/.github/workflows/main.yml?branch=main)][badges:1-workflow]
+
 # 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. 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 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.
 
 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` options such as:
+**NOTE**: The `:auto` option **ONLY** decides between `:destroy` and `:delete` / `:delete_all`. It does not support any other `dependent` option, such as:
 - `:nullify`
 - `:destroy_async`
 - `:restrict_with_error`
@@ -57,3 +60,6 @@ The gem is available as open source under the terms of the [MIT License](https:/
 ## Code of Conduct
 
 Everyone interacting in the Dependent::Auto::Rails project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/dependent-auto-rails/blob/main/CODE_OF_CONDUCT.md).
+
+[badges:0-gem]: https://rubygems.org/gems/dependent-auto-rails
+[badges:1-workflow]: https://github.com/joshuay03/dependent-auto-rails/blob/main/.github/workflows/main.yml

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

@@ -18,23 +18,33 @@ module ActiveRecord
       class DynamicReflectionOptionsHash < Hash
         def [](key)
           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 associated model might not have been evaluated.
           return fallback_method if defining_dependent_callbacks?
 
-          # TODO: This path can be memoized
-          model = super(:association_model_name).constantize
-          return :destroy unless model._destroy_callbacks.empty?
+          @dependent_auto = begin
+            model = super(:association_model_name).constantize
 
-          case super(:association_type)
-          when :singular then :delete
-          when :collection then :delete_all
-          else fallback_method
+            if model._destroy_callbacks.empty?
+              case super(:association_type)
+              when :singular then :delete
+              when :collection then :delete_all
+              else fallback_method
+              end
+            else
+              :destroy
+            end
           end
         end
 
         private
 
         def fallback_method
-          :destroy
+          :destroy # The safest, also common to all supported associations
         end
 
         def defining_dependent_callbacks?

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

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

metadata

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