Adjust header sizing

[rails.git] / config / initializers / composite_primary_keys.rb

diff --git a/config/initializers/composite_primary_keys.rb b/config/initializers/composite_primary_keys.rb
index e928df39f5036a34096b5274eb610d193d2c1a35..ed4d5f2c94a788b998201e398c21b87dfdb826bd 100644 (file)
--- a/config/initializers/composite_primary_keys.rb
+++ b/config/initializers/composite_primary_keys.rb
@@ -1,79 +1,47 @@
+# Monkey patch composite_primary_keys pending the resolution of:
+# https://github.com/composite-primary-keys/composite_primary_keys/pull/170
 module ActiveRecord
   module Associations
-    class AssociationScope
-      def add_constraints(scope)
-        tables = construct_tables
-
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
-
-          if reflection.source_macro == :has_and_belongs_to_many
-            join_table = tables.shift
-
-            # CPK
-            # scope = scope.joins(join(
-            #  join_table,
-            #  table[reflection.active_record_primary_key].
-            #    eq(join_table[reflection.association_foreign_key])
-            #))
-            predicate = cpk_join_predicate(table, reflection.association_primary_key,
-                                           join_table, reflection.association_foreign_key)
-            scope = scope.joins(join(join_table, predicate))
-
-            table, foreign_table = join_table, tables.first
-          end
-
-          if reflection.source_macro == :belongs_to
-            if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(klass)
-            else
-              key = reflection.association_primary_key
-            end
-
-            foreign_key = reflection.foreign_key
+    class HasManyAssociation
+      def delete_records(records, method)
+        if method == :destroy
+          records.each { |r| r.destroy }
+          update_counter(-records.length) unless inverse_updates_counter_cache?
+        else
+          if records == :all
+            scope = self.scope
           else
-            key         = reflection.foreign_key
-            foreign_key = reflection.active_record_primary_key
-          end
-
-          conditions = self.conditions[i]
-
-          if reflection == chain.last
             # CPK
-            # scope = scope.where(table[key].eq(owner[foreign_key]))
-            predicate = cpk_join_predicate(table, key, owner, foreign_key)
-            scope = scope.where(predicate)
-
-            if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
-            end
-
-            conditions.each do |condition|
-              if options[:through] && condition.is_a?(Hash)
-                condition = { table.name => condition }
+            # keys  = records.map { |r| r[reflection.association_primary_key] }
+            # scope = scope.where(reflection.association_primary_key => keys)
+            table = Arel::Table.new(reflection.table_name)
+            and_conditions = records.map do |record|
+              eq_conditions = Array(reflection.association_primary_key).map do |name|
+                table[name].eq(record[name])
               end
-
-              scope = scope.where(interpolate(condition))
+              Arel::Nodes::And.new(eq_conditions)
             end
-          else
-            # CPK
-            # constraint = table[key].eq(foreign_table[foreign_key])
-            constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
-            if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
+            condition = and_conditions.shift
+            and_conditions.each do |and_condition|
+              condition = condition.or(and_condition)
             end
 
-            scope = scope.joins(join(foreign_table, constraint))
+            scope = self.scope.where(condition)
+          end
 
-            unless conditions.empty?
-              scope = scope.where(sanitize(conditions, table))
+          if method == :delete_all
+            update_counter(-scope.delete_all)
+          else
+            # CPK
+            # update_counter(-scope.update_all(reflection.foreign_key => nil))
+            updates = Array(reflection.foreign_key).inject(Hash.new) do |hash, name|
+              hash[name] = nil
+              hash
             end
+            update_counter(-scope.update_all(updates))
           end
         end
-
-        scope
       end
     end
   end