dependent-auto-rails 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15f2727d8f6862ab56a05007412045843f69c69e88f0d12772e339c10b70e93b
-  data.tar.gz: 5cd26614eca9b617e50fe4ab32cda5dcef69e425037612a4a2bc43675f1e5cdb
+  metadata.gz: a862d80808c8cc6d619f6c5d2b2b2eb064a54f1382ee27a806f81608e5d83165
+  data.tar.gz: e6c078c89f423af15585de3a697688fb314aa24ffb3995005f479cb2c6ac4650
 SHA512:
-  metadata.gz: 6b01ed5650b3ac1667c72f350c9ab1ced6814fe77f6310328378cb8e9dae70b1bbe88366fd805c5cf64fb7ad66b7d5043717612974998c722904e62da52792f7
-  data.tar.gz: 300d41e5b3b117090639f105bf3682881de682631775fc7485ecf9a8b8392fa67762df99fd4c69bf1b324505c713a0864f5d67c6976395dc5b3e41558d01f679
+  metadata.gz: bee37a9ce116600e8458bd1af1580011e0fd91ea9f2cf70eb91b5e62ce9f3ab353cce542e0d6f8ce3fd973aaea70149df915a4411f5d47841a728cd6ac4de988
+  data.tar.gz: 6aceba442aae030f9eeebb8735623a89823b018ddf531ffcde1c9d179fffbe1b4b892bd8c2b046eccc20a819018c4fddcf3904089cf0de30512959958d239354

data/README.md

@@ -1,24 +1,44 @@
-# [WIP] Dependent::Auto::Rails
+# dependent-auto-rails
 
-TODO: Delete this and the text below, and describe your gem
+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.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/dependent/auto/rails`. To experiment with that code, run `bin/console` for an interactive prompt.
+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.
 
-## Installation
+**NOTE**: The `:auto` option **ONLY** decides between `:destroy` and `:delete` / `:delete_all`. It does not support any other `dependent` options such as:
+- `:nullify`
+- `:destroy_async`
+- `:restrict_with_error`
+- `:restrict_with_exception`
+
+**NOTE**: If for some reason the `:auto` option is unable to decide between `:destroy` and `:delete` / `:delete_all`, it will default to `:destroy`.
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+## Installation
 
-Install the gem and add to the application's Gemfile by executing:
+Install the gem and add it to the application's Gemfile by executing:
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ bundle add dependent-auto-rails
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+    $ gem installdependent-auto-rails
 
 ## Usage
 
-TODO: Write usage instructions here
+To use this gem, all you need to do is add `dependent: :auto` to your model associations where you would usually use one of:
+ - `dependent: :destroy` (`belongs_to`, `has_one`, `has_many`)
+ - `dependent: :delete` (`belongs_to`, `has_one`)
+ - `dependent: :delete_all` (`has_many`).
+
+```ruby
+class Post < ApplicationRecord
+  belongs_to :author, dependent: :auto
+
+  has_one :pinned_comment, dependent: :auto
+
+  has_many :comments, dependent: :auto
+end
+
+```
 
 ## Development
 
@@ -28,7 +48,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dependent-auto-rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/dependent-auto-rails/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshuay03/dependent-auto-rails. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/dependent-auto-rails/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 

data/lib/dependent-auto-rails/activerecord/associations/builder/belongs_to.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder
+  class BelongsTo < SingularAssociation
+    def self.valid_dependent_options
+      [:auto, :destroy, :delete, :destroy_async]
+    end
+    private_class_method :valid_dependent_options
+  end
+end

data/lib/dependent-auto-rails/activerecord/associations/builder/has_many.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder
+  class HasMany < CollectionAssociation
+    def self.valid_dependent_options
+      [:auto, :destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception, :destroy_async]
+    end
+    private_class_method :macro, :valid_options, :valid_dependent_options
+  end
+end

data/lib/dependent-auto-rails/activerecord/associations/builder/has_one.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Associations::Builder
+  class HasOne < SingularAssociation
+    def self.valid_dependent_options
+      [:auto, :destroy, :destroy_async, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
+    end
+    private_class_method :valid_dependent_options
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Reflection
+    class AssociationReflection < MacroReflection
+      private
+
+      def convert_options_to_dynamic_reflection_options!
+        @options = DynamicReflectionOptionsHash.new.merge!(
+          @options,
+          {
+            association_model_name: class_name,
+            association_type: collection? ? :collection : :singular
+          }
+        )
+      end
+
+      class DynamicReflectionOptionsHash < Hash
+        def [](key)
+          return super unless key == :dependent && super(:dependent) == :auto
+          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?
+
+          case super(:association_type)
+          when :singular then :delete
+          when :collection then :delete_all
+          else fallback_method
+          end
+        end
+
+        private
+
+        def fallback_method
+          :destroy
+        end
+
+        def defining_dependent_callbacks?
+          caller.any? { |line| line.include?("active_record/associations/builder/association.rb") }
+        end
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection
+      def initialize(...)
+        super(...)
+        convert_options_to_dynamic_reflection_options!
+      end
+    end
+
+    class HasOneReflection < AssociationReflection
+      def initialize(...)
+        super(...)
+        convert_options_to_dynamic_reflection_options!
+      end
+    end
+
+    class HasManyReflection < AssociationReflection
+      def initialize(...)
+        super(...)
+        convert_options_to_dynamic_reflection_options!
+      end
+    end
+
+    class HasAndBelongsToManyReflection < AssociationReflection
+      def initialize(...)
+        super(...)
+        convert_options_to_dynamic_reflection_options!
+      end
+    end
+  end
+end

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

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

data/lib/dependent-auto-rails.rb

@@ -3,7 +3,10 @@
 require "active_record"
 
 ActiveSupport.on_load(:active_record) do
-  require_relative "dependent-auto-rails/activerecord/associations/builder/association"
+  require_relative "dependent-auto-rails/activerecord/associations/builder/belongs_to"
+  require_relative "dependent-auto-rails/activerecord/associations/builder/has_one"
+  require_relative "dependent-auto-rails/activerecord/associations/builder/has_many"
+  require_relative "dependent-auto-rails/activerecord/reflection"
 end
 
 module DependentAutoRails

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dependent-auto-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Joshua Young
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-19 00:00:00.000000000 Z
+date: 2024-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -50,7 +50,10 @@ files:
 - LICENSE.txt
 - README.md
 - lib/dependent-auto-rails.rb
-- lib/dependent-auto-rails/activerecord/associations/builder/association.rb
+- lib/dependent-auto-rails/activerecord/associations/builder/belongs_to.rb
+- lib/dependent-auto-rails/activerecord/associations/builder/has_many.rb
+- lib/dependent-auto-rails/activerecord/associations/builder/has_one.rb
+- lib/dependent-auto-rails/activerecord/reflection.rb
 - lib/dependent-auto-rails/version.rb
 homepage: https://github.com/joshuay03/dependent-auto-rails
 licenses:
@@ -77,6 +80,6 @@ requirements: []
 rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
-summary: Automatically and safely decides between :destroy and :delete / :delete_all
-  for your Rails associations.
+summary: Automatically decides between :destroy and :delete / :delete_all for your
+  Rails associations.
 test_files: []

data/lib/dependent-auto-rails/activerecord/associations/builder/association.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord::Associations::Builder
-  class Association
-    def self.create_reflection(model, name, scope, options, &block)
-      raise ArgumentError, "association names must be a Symbol" unless name.is_a?(Symbol)
-
-      validate_options(options)
-
-      extension = define_extensions(model, name, &block)
-      options[:extend] = [*options[:extend], extension] if extension
-
-      scope = build_scope(scope)
-
-      ActiveRecord::Reflection.create(macro, name, scope, dynamic_reflection_options(model, options), model)
-    end
-
-    def self.dynamic_reflection_options(model, options)
-      DynamicReflectionOptionsHash.new.merge!(
-        options,
-        {
-          model_name: model.name,
-          association_type: if self < ActiveRecord::Associations::Builder::SingularAssociation
-                              :singular
-                            elsif self < ActiveRecord::Associations::Builder::CollectionAssociation
-                              :collection
-                            else
-                              raise DependentAutoRails::Error, "Unsupported association type"
-                            end
-        }
-      )
-    end
-    private_class_method :dynamic_reflection_options
-
-    class DynamicReflectionOptionsHash < Hash
-      def [](key)
-        return super unless key == :dependent && super(:dependent) == :auto
-        return fallback_method if defining_dependent_callbacks?
-
-        model = super(:model_name).constantize
-        return :destroy unless valid_destroy_callbacks(model).empty?
-
-        case super(:association_type)
-        when :singular then :delete
-        when :collection then :delete_all
-        else fallback_method
-        end
-      end
-
-      private
-
-      def fallback_method
-        :destroy
-      end
-
-      def defining_dependent_callbacks?
-        caller.any? { |line| line.include?("active_record/associations/builder/association.rb") }
-      end
-
-      def valid_destroy_callbacks(model)
-        model._destroy_callbacks.reject do |callback|
-          # ignore #handle_dependency callback
-          callback.filter.to_s.include?("active_record/associations/builder/association.rb")
-        end
-      end
-    end
-  end
-end