dependent-auto-rails 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8a5de40e738a480461d249edc98b76df49778d58e77fee8a3a54f90ffa017ad
-  data.tar.gz: 8bbb14703a6e1a20da97cde693f05000f77202eae0e05ecbfe37d0fd7ce8d749
+  metadata.gz: b0596b3547afda10b9f5dbde19305f2f82513c08f0e0f2cbba8ea61d6c7d3e36
+  data.tar.gz: 34d8c36bcec58674d9b1d98f130335e102896493ab7a86aba4ee7ff1aada0b28
 SHA512:
-  metadata.gz: 828ba4145c234101a34c753c6d247739f4ee97734a8ab1a5c065d443e5b60cdcb97713c7180d0fc317ba536760827363ec14cb8676e4b59bd628b0f38e00f4ad
-  data.tar.gz: 1efacf7ea4308f2afe9e7d998ed0fc8fa9e8e23bf06bd0d8ee484c10a7e4bc5ea3cc50a61588577ab8163854b123ae884204255362287e93b832f3396ce1d806
+  metadata.gz: fb17812a18ac89155498d56a7a11fbdc36076c9f0859765e18dd6abbaf33d26d7495582cf294b9f464fe49fc316eb23ed529c52dc94e91d7a0098782119a9bbb
+  data.tar.gz: e242a528349742be08232e9fae587d630de0d78db8962151ff64af97b414d668dc3f62db70b82cac136692a7bd9d345a8c99420384408f0a1430237191303469

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,63 @@
+# 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
+
+module ActiveRecord
+  module Associations
+    class HasManyAssociation < CollectionAssociation
+      def handle_dependency
+        case options[:dependent]
+        when :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = owner.class.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.has_many", record: record)
+            throw(:abort)
+          end
+
+        when :destroy
+          # No point in executing the counter update since we're going to destroy the parent anyway
+          load_target.each { |t| t.destroyed_by_association = reflection }
+          destroy_all
+        when :destroy_async
+          load_target.each do |t|
+            t.destroyed_by_association = reflection
+          end
+
+          unless target.empty?
+            association_class = target.first.class
+            if association_class.query_constraints_list
+              primary_key_column = association_class.query_constraints_list.map(&:to_sym)
+              ids = target.collect { |assoc| primary_key_column.map { |col| assoc.public_send(col) } }
+            else
+              primary_key_column = association_class.primary_key.to_sym
+              ids = target.collect { |assoc| assoc.public_send(primary_key_column) }
+            end
+
+            ids.each_slice(owner.class.destroy_association_async_batch_size || ids.size) do |ids_batch|
+              enqueue_destroy_association(
+                owner_model_name: owner.class.to_s,
+                owner_id: owner.id,
+                association_class: reflection.klass.to_s,
+                association_ids: ids_batch,
+                association_primary_key_column: primary_key_column,
+                ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+              )
+            end
+          end
+        else
+          delete_all
+        end
+      end
+    end
+  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,80 @@
+# 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?
+
+          model = super(:association_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
+
+    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.4"
+  VERSION = "0.1.6"
 end

data/lib/dependent-auto-rails.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+ActiveSupport.on_load(:active_record) do
+  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
+  class Error < StandardError; end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dependent-auto-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 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
@@ -49,17 +49,19 @@ files:
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
-- lib/dependent-auto-rails/activerecord/associations/builder/association.rb
-- lib/dependent-auto-rails/dependent_auto_rails.rb
+- lib/dependent-auto-rails.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:
 - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/joshuay03/dependent-auto-rails
   source_code_uri: https://github.com/joshuay03/dependent-auto-rails
-  changelog_uri: https://github.com/joshuay03/dependent-auto-rails/CHANGELOG.md
+  changelog_uri: https://github.com/joshuay03/dependent-auto-rails/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:

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

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-
-ActiveSupport.on_load(:active_record) do
-  require "dependent-auto-rails/activerecord/associations/builder/association"
-end
-
-module DependentAutoRails
-  class Error < StandardError; end
-end