bulk_dependency_eraser 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc8c21921516530d646fff41d72ce0157e1d706373eefea4da7ea924bb1cb9b9
-  data.tar.gz: 9501007142223dfad5cb05e89ab38162499b564eaaf3636074e3cd54a573592f
+  metadata.gz: cbea15215c816eca6790c1d7c3cbf4f4f68534fc3ff18cc38e8c26dc7e94513d
+  data.tar.gz: 532a711c1290ea4fea4200acc75d9916eb18a2451207b89d1163372d7372028d
 SHA512:
-  metadata.gz: 0f461d596eb9160828f0905dde68396ade1409f8f9c17de2e4bb8677cb12695be59c75f6fa33d84d9156a2b10fdab2eed869b7f19a79c84e1526c705ac4cf58b
-  data.tar.gz: 64777768e6eb815d575d11690cb793962ab4fcb24911bc2bb209d5d7a33d3bc660b6d939fe287ca2c41dcac8524efe95032f3b6ee76272956391589193315666
+  metadata.gz: e5639d23e7fbad812f11db05ad4b4dc3e88cd8823b3623ec38c892ed144ca6002b2e6bf56a826cca62aa2e87312fc676ac0668d1d6301a66496f91a62c7896fe
+  data.tar.gz: 20f81c4ddae6e875de07849088493f21095a567ccf2e1e39bfe21bbe1486dbfaa76ad06bc53f247724ca0f5e79a7f7af699e480345c2b5a800f617c06bb83844

data/lib/bulk_dependency_eraser/builder.rb

@@ -209,19 +209,24 @@ module BulkDependencyEraser
       nullify_association_names    = nullify_associations.map(&:name)
       restricted_association_names = restricted_associations.map(&:name)
 
-      if opts_c.verbose
-        puts "Destroyable Associations: #{destroy_association_names}"
-        puts "Nullifiable Associations: #{nullify_association_names}"
-        puts " Restricted Associations: #{restricted_association_names}"
-      end
-
-      # Iterate through the assoc names, if there are any :through assocs, then remap 
+      # Iterate through the assoc names, if there are any :through assocs, then rename the association
+      # - Rails interpretation of any dependencies of a :through association is to apply it to
+      #   the leaf association at the end of the :through chain(s)
       destroy_association_names = destroy_association_names.collect do |assoc_name|
         find_root_association_from_through_assocs(klass, assoc_name)
       end
       nullify_association_names = nullify_association_names.collect do |assoc_name|
         find_root_association_from_through_assocs(klass, assoc_name)
       end
+      restricted_association_names = restricted_association_names.collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+
+      if opts_c.verbose
+        puts "Destroyable Associations: #{destroy_association_names}"
+        puts "Nullifiable Associations: #{nullify_association_names}"
+        puts " Restricted Associations: #{restricted_association_names}"
+      end
 
       destroy_association_names.each do |destroy_association_name|
         association_parser(klass, query, query_ids, destroy_association_name, :delete)
@@ -255,7 +260,7 @@ module BulkDependencyEraser
       when 'ActiveRecord::Reflection::HasManyReflection'
         association_parser_has_many(parent_class, query, query_ids, association_name, type)
       when 'ActiveRecord::Reflection::HasOneReflection'
-        association_parser_has_many(parent_class, query, query_ids, association_name, type, { limit: 1 })
+        association_parser_has_many(parent_class, query, query_ids, association_name, type)
       when 'ActiveRecord::Reflection::BelongsToReflection'
         if type == :nullify
           report_error("#{parent_class.name}'s association '#{association_name}' - dependent 'nullify' invalid for 'belongs_to'")
@@ -342,10 +347,11 @@ module BulkDependencyEraser
         assoc_query = assoc_query.where(specified_foreign_key.to_sym => query_ids)
       end
 
-      # Apply limit if has_one assocation (subset of has_many)
-      if opts[:limit]
-        assoc_query = assoc_query.limit(opts[:limit])
-      end
+      # Works in theory for ONE record's has_one, but we're dealing with potentially many
+      # # Apply limit if has_one assocation (subset of has_many)
+      # if opts[:limit]
+      #   assoc_query = assoc_query.limit(opts[:limit])
+      # end
 
       if type == :delete
         # Recursively call 'deletion_query_parser' on association query, to delete any if the assoc's dependencies

data/lib/bulk_dependency_eraser/manager.rb

@@ -24,8 +24,7 @@ module BulkDependencyEraser
         return false unless build
       end
 
-      delete!
-      nullify!
+      nullify! && delete!
 
       return errors.none?
     end

data/lib/bulk_dependency_eraser/nullifier.rb

@@ -2,7 +2,11 @@ module BulkDependencyEraser
   class Nullifier < Base
     DEFAULT_OPTS = {
       verbose: false,
-      db_nullify_wrapper: self::DEFAULT_DB_WRAPPER
+      db_nullify_wrapper: self::DEFAULT_DB_WRAPPER,
+      # Set to true if you want 'ActiveRecord::InvalidForeignKey' errors raised during nullifications
+      # - I can't think of a use-case where a nullification would generate an invalid key error
+      # - Not hurting anything to leave it in, but might remove it in the future.
+      enable_invalid_foreign_key_detection: false
     }.freeze
 
     DEFAULT_DB_WRAPPER = ->(block) do
@@ -22,6 +26,53 @@ module BulkDependencyEraser
     def initialize class_names_columns_and_ids:, opts: {}
       @class_names_columns_and_ids = class_names_columns_and_ids
       super(opts:)
+
+      if opts_c.verbose
+        puts "Combining nullification column groups (if groupable)"
+        puts "Before Combination: #{@class_names_columns_and_ids}"
+      end
+
+      @class_names_columns_and_ids = combine_matching_columns(@class_names_columns_and_ids)
+
+      if opts_c.verbose
+        puts "After Combination: #{@class_names_columns_and_ids}"
+      end
+    end
+
+    # Combine columns if the IDs are the same
+    # - will do one SQL call instead of several
+    def combine_matching_columns(nullification_hash)
+      return {} if nullification_hash.none?
+
+      merged_hash = {}
+
+      nullification_hash.each do |klass_name, columns_and_ids|
+        merged_hash[klass_name] = {}
+        columns_and_ids.each do |key, array|
+          sorted_array = array.sort
+
+          # Find any existing key in merged_hash that has the same sorted array
+          matching_key = merged_hash[klass_name].keys.find { |k| merged_hash[klass_name][k].sort == sorted_array }
+
+          if matching_key
+            # Concatenate the matching keys and update the hash
+            new_key = key.is_a?(Array) ? key : [key]
+            if matching_key.is_a?(Array)
+              new_key += matching_key
+            else
+              new_key << matching_key
+            end
+
+            merged_hash[klass_name][new_key] = sorted_array
+            merged_hash[klass_name].delete(matching_key)
+          else
+            # Otherwise, just add the current key-value pair
+            merged_hash[klass_name][key] = sorted_array
+          end
+        end
+      end
+
+      merged_hash
     end
 
     def execute
@@ -34,15 +85,19 @@ module BulkDependencyEraser
             klass = class_name.constantize
 
             columns_and_ids = class_names_columns_and_ids[class_name]
-
             columns_and_ids.each do |column, ids|
               current_column = column
-              # Disable any ActiveRecord::InvalidForeignKey raised errors.
-              # src https://stackoverflow.com/questions/41005849/rails-migrations-temporarily-ignore-foreign-key-constraint
-              #     https://apidock.com/rails/ActiveRecord/ConnectionAdapters/AbstractAdapter/disable_referential_integrity
-              ActiveRecord::Base.connection.disable_referential_integrity do
-                nullify_in_db do
-                  klass.unscoped.where(id: ids).update_all(column => nil)
+
+              if opts_c.enable_invalid_foreign_key_detection
+                # nullify with referential integrity
+                nullify_by_klass_column_and_ids(klass, column, ids)
+              else
+                # nullify without referential integrity
+                # Disable any ActiveRecord::InvalidForeignKey raised errors.
+                # - src: https://stackoverflow.com/questions/41005849/rails-migrations-temporarily-ignore-foreign-key-constraint
+                #        https://apidock.com/rails/ActiveRecord/ConnectionAdapters/AbstractAdapter/disable_referential_integrity
+                ActiveRecord::Base.connection.disable_referential_integrity do
+                  nullify_by_klass_column_and_ids(klass, column, ids)
                 end
               end
             end
@@ -60,6 +115,23 @@ module BulkDependencyEraser
 
     attr_reader :class_names_columns_and_ids
 
+    def nullify_by_klass_column_and_ids klass, columns, ids
+      nullify_columns = {}
+
+      # supporting nullification of groups of columns simultaneously
+      if columns.is_a?(Array)
+        columns.each do |column|
+          nullify_columns[column] = nil
+        end
+      else
+        nullify_columns[columns] = nil
+      end
+
+      nullify_in_db do
+        klass.unscoped.where(id: ids).update_all(nullify_columns)
+      end
+    end
+
     def nullify_in_db(&block)
       puts "Nullifying from DB..." if opts_c.verbose
       opts_c.db_nullify_wrapper.call(block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bulk_dependency_eraser
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
 - benjamin.dana.software.dev@gmail.com