composite_primary_keys 12.0.10 → 13.0.3

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -1,32 +1,32 @@
-module CompositePrimaryKeys
-  module CollectionAssociation
-    def ids_writer(ids)
-      primary_key = reflection.association_primary_key
-      pk_type = klass.type_for_attribute(primary_key)
-      ids = Array(ids).reject(&:blank?)
-      ids.map! { |i| pk_type.cast(i) }
-
-      # CPK-
-      if primary_key.is_a?(Array)
-        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
-        records = klass.where(predicate).index_by do |r|
-          reflection.association_primary_key.map{ |k| r.send(k) }
-        end.values_at(*ids)
-      else
-        records = klass.where(primary_key => ids).index_by do |r|
-          r.public_send(primary_key)
-        end.values_at(*ids).compact
-      end
-
-      if records.size != ids.size
-        found_ids = records.map { |record| record.public_send(primary_key) }
-        not_found_ids = ids - found_ids
-        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
-      else
-        replace(records)
-      end
-    end
-  end
-end
-
+module CompositePrimaryKeys
+  module CollectionAssociation
+    def ids_writer(ids)
+      primary_key = reflection.association_primary_key
+      pk_type = klass.type_for_attribute(primary_key)
+      ids = Array(ids).reject(&:blank?)
+      ids.map! { |i| pk_type.cast(i) }
+
+      # CPK-
+      if primary_key.is_a?(Array)
+        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
+        records = klass.where(predicate).index_by do |r|
+          reflection.association_primary_key.map{ |k| r.send(k) }
+        end.values_at(*ids)
+      else
+        records = klass.where(primary_key => ids).index_by do |r|
+          r.public_send(primary_key)
+        end.values_at(*ids).compact
+      end
+
+      if records.size != ids.size
+        found_ids = records.map { |record| record.public_send(primary_key) }
+        not_found_ids = ids - found_ids
+        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
+      else
+        replace(records)
+      end
+    end
+  end
+end
+
 ActiveRecord::Associations::CollectionAssociation.prepend CompositePrimaryKeys::CollectionAssociation

data/lib/composite_primary_keys/associations/foreign_association.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module ActiveRecord::Associations
-  module ForeignAssociation # :nodoc:
-    def foreign_key_present?
-      if reflection.klass.primary_key
-        # CPK
-        # owner.attribute_present?(reflection.active_record_primary_key)
-        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
-      else
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ActiveRecord::Associations
+  module ForeignAssociation # :nodoc:
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        # CPK
+        # owner.attribute_present?(reflection.active_record_primary_key)
+        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
+      else
+        false
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,35 +1,35 @@
-module ActiveRecord
-  module Associations
-    class HasManyAssociation
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
-        # CPK
-        elsif self.reflection.klass.composite?
-          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
-          scope = self.scope.where(predicate)
-          update_counter(-delete_count(method, scope))
-        else
-          scope = self.scope.where(reflection.klass.primary_key => records)
-          update_counter(-delete_count(method, scope))
-        end
-      end
-
-      def delete_count(method, scope)
-        if method == :delete_all
-          scope.delete_all
-        else
-          # CPK
-          # scope.update_all(nullified_owner_attributes)
-          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
-            mem[key] = nil
-            mem
-          end
-          conds[reflection.type] = nil if reflection.type.present?
-          scope.update_all(conds)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class HasManyAssociation
+      def delete_records(records, method)
+        if method == :destroy
+          records.each(&:destroy!)
+          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
+        # CPK
+        elsif self.reflection.klass.composite?
+          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
+          scope = self.scope.where(predicate)
+          update_counter(-delete_count(method, scope))
+        else
+          scope = self.scope.where(reflection.klass.primary_key => records)
+          update_counter(-delete_count(method, scope))
+        end
+      end
+
+      def delete_count(method, scope)
+        if method == :delete_all
+          scope.delete_all
+        else
+          # CPK
+          # scope.update_all(nullified_owner_attributes)
+          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
+            mem[key] = nil
+            mem
+          end
+          conds[reflection.type] = nil if reflection.type.present?
+          scope.update_all(conds)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/{join_dependency.rb → join_association.rb}

@@ -1,103 +1,137 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class Aliases # :nodoc:
-        def column_alias(node, column)
-          # CPK
-          #@alias_cache[node][column]
-          if column.kind_of?(Array)
-            column.map do |a_column|
-              @alias_cache[node][a_column]
-            end
-          else
-            @alias_cache[node][column]
-          end
-        end
-      end
-
-      def instantiate(result_set, &block)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h, klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-            record_count: result_set.length,
-            class_name: join_root.base_klass.name
-        }
-
-        message_bus.instrument("instantiation.active_record", payload) do
-          result_set.each { |row_hash|
-            # CPK
-            # parent_key = primary_key ? row_hash[primary_key] : row_hash
-            # CPK
-            parent_key = if primary_key.kind_of?(Array)
-                           primary_key.map {|key| row_hash[key]}
-                         else
-                           primary_key ? row_hash[primary_key] : row_hash
-                         end
-
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, seen, model_cache)
-          }
-        end
-
-        parents.values
-      end
-
-      def construct(ar_parent, parent, row, seen, model_cache)
-        return if ar_parent.nil?
-
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          elsif ar_parent.association_cached?(node.reflection.name)
-            model = ar_parent.association(node.reflection.name).target
-            construct(model, node, row, seen, model_cache)
-            next
-          end
-
-          key = aliases.column_alias(node, node.primary_key)
-
-          # CPK
-          if key.is_a?(Array)
-            id = Array(key).map do |column_alias|
-              row[column_alias]
-            end
-            # At least the first value in the key has to be set.  Should we require all values to be set?
-            id = nil if id.first.nil?
-          else # original
-            id = row[key]
-          end
-
-          if id.nil? # duplicating this so it is clear what remained unchanged from the original
-            nil_association = ar_parent.association(node.reflection.name)
-            nil_association.loaded!
-            next
-          end
-
-          model = seen[ar_parent.object_id][node][id]
-
-          if model
-            construct(model, node, row, seen, model_cache)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id)
-
-            seen[ar_parent.object_id][node][id] = model
-            construct(model, node, row, seen, model_cache)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+
+      class JoinAssociation < JoinPart # :nodoc:
+        private
+          def append_constraints(join, constraints)
+            if join.is_a?(Arel::Nodes::StringJoin)
+              join_string = Arel::Nodes::And.new(constraints.unshift join.left)
+              join.left = Arel.sql(base_klass.connection.visitor.compile(join_string))
+            else
+              right = join.right
+              # CPK
+              if right.expr.is_a?(Arel::Nodes::And) && right.expr.children.empty?
+                right.expr = Arel::Nodes::And.new(constraints)
+              else
+                right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)
+              end
+            end
+          end
+      end
+
+      class Aliases # :nodoc:
+        def column_alias(node, column)
+          # CPK
+          #@alias_cache[node][column]
+          if column.kind_of?(Array)
+            column.map do |a_column|
+              @alias_cache[node][a_column]
+            end
+          else
+            @alias_cache[node][column]
+          end
+        end
+      end
+
+      def instantiate(result_set, strict_loading_value, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }.compare_by_identity
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            # CPK
+            # parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent_key = if primary_key.kind_of?(Array)
+                           primary_key.map {|key| row_hash[key]}
+                         else
+                           primary_key ? row_hash[primary_key] : row_hash
+                         end
+
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
+          }
+        end
+
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+        return if ar_parent.nil?
+
+        parent.children.each do |node|
+          if node.reflection.collection?
+            other = ar_parent.association(node.reflection.name)
+            other.loaded!
+          elsif ar_parent.association_cached?(node.reflection.name)
+            model = ar_parent.association(node.reflection.name).target
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+            next
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+          # CPK
+          if key.is_a?(Array)
+            id = Array(key).map do |column_alias|
+              row[column_alias]
+            end
+            # At least the first value in the key has to be set.  Should we require all values to be set?
+            id = nil if id.first.nil?
+          else # original
+            id = row[key]
+          end
+
+          if id.nil?
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
+
+          model = seen[ar_parent][node][id]
+
+          if model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          else
+            model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
+
+            seen[ar_parent][node][id] = model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/through_association.rb

@@ -5,8 +5,7 @@ module ActiveRecord
 
       def construct_join_attributes(*records)
         # CPK
-        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
-        if is_composite
+        if !self.source_reflection.polymorphic? && source_reflection.klass.composite?
           ensure_mutable
 
           ids = records.map do |record|

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -16,7 +16,6 @@ module ActiveRecord
 
       # Returns the primary key previous value.
       def id_was
-        sync_with_transaction_state
         # CPK
         # attribute_was(self.class.primary_key)
         if self.composite?
@@ -29,7 +28,6 @@ module ActiveRecord
       end
 
       def id_in_database
-        sync_with_transaction_state
         # CPK
         # attribute_in_database(self.class.primary_key)
         if self.composite?

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         # CPK
         # name = primary_key if name == "id" && primary_key
         name = primary_key if name == "id" && primary_key && !composite?
-        sync_with_transaction_state if name == primary_key
+
         _read_attribute(name, &block)
       end
 

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -13,7 +13,7 @@ module ActiveRecord
         # CPK
         # name = primary_key if name == "id" && primary_key
         name = primary_key if name == "id" && primary_key && !composite?
-        sync_with_transaction_state if name == primary_key
+
         _write_attribute(name, value)
       end
 

data/lib/composite_primary_keys/attribute_methods.rb

@@ -2,8 +2,20 @@ module ActiveRecord
   module AttributeMethods
     def has_attribute?(attr_name)
       # CPK
-      # @attributes.key?(attr_name.to_s)
-      Array(attr_name).all? {|single_attr| @attributes.key?(single_attr.to_s) }
+      # attr_name = attr_name.to_s
+      # attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      # @attributes.key?(attr_name)
+      Array(attr_name).all? do |attr|
+        attr = attr.to_s
+        attr = self.class.attribute_aliases[attr] || attr
+        @attributes.key?(attr)
+      end
+    end
+
+    def _has_attribute?(attr_name)
+      # CPK
+      # @attributes.key?(attr_name)
+      Array(attr_name).all? { |attr| @attributes.key?(attr) }
     end
   end
 end

data/lib/composite_primary_keys/autosave_association.rb

@@ -1,60 +1,60 @@
-module ActiveRecord
-  module AutosaveAssociation
-    def save_has_one_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.load_target
-
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          record.destroy
-        elsif autosave != false
-          # CPK
-          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
-
-          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
-            unless reflection.through_reflection
-              record[reflection.foreign_key] = key
-              if inverse_reflection = reflection.inverse_of
-                record.association(inverse_reflection.name).loaded!
-              end
-            end
-
-            saved = record.save(validate: !autosave)
-            raise ActiveRecord::Rollback if !saved && autosave
-            saved
-          end
-        end
-      end
-    end
-
-    def save_belongs_to_association(reflection)
-      association = association_instance_get(reflection.name)
-      return unless association && association.loaded? && !association.stale_target?
-
-      record = association.load_target
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          self[reflection.foreign_key] = nil
-          record.destroy
-        elsif autosave != false
-          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
-
-          if association.updated?
-            # CPK
-            # association_id = record.send(reflection.options[:primary_key] || :id)
-            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
-            self[reflection.foreign_key] = association_id
-            association.loaded!
-          end
-
-          saved if autosave
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AutosaveAssociation
+    def save_has_one_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          # CPK
+          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
+
+          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+              if inverse_reflection = reflection.inverse_of
+                record.association(inverse_reflection.name).loaded!
+              end
+            end
+
+            saved = record.save(validate: !autosave)
+            raise ActiveRecord::Rollback if !saved && autosave
+            saved
+          end
+        end
+      end
+    end
+
+    def save_belongs_to_association(reflection)
+      association = association_instance_get(reflection.name)
+      return unless association && association.loaded? && !association.stale_target?
+
+      record = association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
+          record.destroy
+        elsif autosave != false
+          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+
+          if association.updated?
+            # CPK
+            # association_id = record.send(reflection.options[:primary_key] || :id)
+            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
+            self[reflection.foreign_key] = association_id
+            association.loaded!
+          end
+
+          saved if autosave
+        end
+      end
+    end
+  end
+end