composite_primary_keys 13.0.2 → 14.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eeb7ac69a866392d1d19aec7ae67f99af052e72e5585375c2cb73990f442cc28
-  data.tar.gz: 6552f1e74d6ab9a40aadd66ea78e8d6c489e6d793a47cc52ab2582f60dfbced7
+  metadata.gz: c9cb00a73781e630f40a83391449a048e05a28e6c93ab41b71af55ad7d0e5aa1
+  data.tar.gz: ef9cdf02f59b135080e2eefa621d35764a7a4002904aaa066031675b2bf05873
 SHA512:
-  metadata.gz: 1b0bd53df9177d3569e4646124ff2aaf6bacf4d83a78f287a9e954ed388a37ed4872f4024204e34f7402b7989b401586c53636a551d745e5aaf4871927bb66fb
-  data.tar.gz: 8c2eacaaff041c6c4255aed0402f63038d6e0d781665208cbb9b3bdbcc86666087f69822400384f9dfc44215c23be46ddc1c3c69b7ee0008db636d8ff1e0a29c
+  metadata.gz: 422d8d5bc43d9b477e2d8dee49235580ff532c961ce1947ac8a09e47b13b2e6eaa484e0ee8045f4fc9bdebf1c0ffb50ca197e243a4d8e93c43909d16640a8433
+  data.tar.gz: 7cc5b56bbb3749d9edf5aef12d4e231e07496eb5f76a605cb7de436b99958a7b6a9aaab9160bdf51b43404b15175a7c93ee02ce6d00d5140e92a68bd7b42f0cc

data/History.rdoc

@@ -1,3 +1,22 @@
+== 14.0.3 (2022-01-09)
+* Remove override on ActiveRecord::Base#to_param. That method has moved to Integration
+  so no longer works. #541. (Charlie Savage)
+* Check if an assocation is polymorhpic. Fixes #558.
+
+== 14.0.2 (2022-01-09)
+* Fix scoped associations take #2 (Charlie Savage)
+
+== 14.0.1 (2022-01-9)
+* Fix mistake in Gemfile (Charlie Savage)
+
+== 14.0.0 (2022-01-9)
+* Update to ActiveRecord 7.0 (Sammy Larbi)
+
+== 13.0.3 (2022-01-09)
+* Remove override on ActiveRecord::Base#to_param. That method has moved to Integration
+  so no longer works. #541. (Charlie Savage)
+* Check if an assocation is polymorhpic. Fixes #558.
+
 == 13.0.2 (2022-01-09)
 * Fix scoped associations take #2 (Charlie Savage)
 

data/README.rdoc

@@ -20,6 +20,7 @@ Every major version of ActiveRecord has included numerous internal changes.  As
 CPK has to be rewritten for each version of ActiveRecord.  To help keep
 things straight, here is the mapping:
 
+    Version 14.x is designed to work with ActiveRecord 7.0.x
     Version 13.x is designed to work with ActiveRecord 6.1.x
     Version 12.x is designed to work with ActiveRecord 6.0.x
     Version 11.x is designed to work with ActiveRecord 5.2.x

data/lib/composite_primary_keys/associations/join_association.rb

@@ -1,137 +1,137 @@
-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
+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/preloader/association.rb

@@ -2,6 +2,20 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association
+
+        class LoaderQuery
+          def load_records_for_keys(keys, &block)
+            # CPK
+            if association_key_name.is_a?(Array)
+              predicate = cpk_in_predicate(scope.klass.arel_table, association_key_name, keys)
+              scope.where(predicate).load(&block)
+            else
+              scope.where(association_key_name => keys).load(&block)
+            end
+          end
+        end
+
+        # TODO: is records_for needed anymore? Rails' implementation has changed significantly
         def records_for(ids)
           records = if association_key_name.is_a?(Array)
                       predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
@@ -33,6 +47,7 @@ module ActiveRecord
           end
         end
 
+        # TODO: is records_by_owner needed anymore? Rails' implementation has changed significantly
         def records_by_owner
           @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
             key = if association_key_name.is_a?(Array)

data/lib/composite_primary_keys/associations/through_association.rb

@@ -1,25 +1,24 @@
-module ActiveRecord
-  module Associations
-    module ThroughAssociation
-      alias :original_construct_join_attributes :construct_join_attributes
-
-      def construct_join_attributes(*records)
-        # CPK
-        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
-        if is_composite
-          ensure_mutable
-
-          ids = records.map do |record|
-            source_reflection.association_primary_key(reflection.klass).map do |key|
-              record.send(key)
-            end
-          end
-
-          cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
-        else
-          original_construct_join_attributes(*records)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    module ThroughAssociation
+      alias :original_construct_join_attributes :construct_join_attributes
+
+      def construct_join_attributes(*records)
+        # CPK
+        if !self.source_reflection.polymorphic? && source_reflection.klass.composite?
+          ensure_mutable
+
+          ids = records.map do |record|
+            source_reflection.association_primary_key(reflection.klass).map do |key|
+              record.send(key)
+            end
+          end
+
+          cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
+        else
+          original_construct_join_attributes(*records)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -1,141 +1,137 @@
-module ActiveRecord
-  class CompositeKeyError < StandardError #:nodoc:
-  end
-
-  class Base
-    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
-
-    class << self
-      alias_method :primary_key_without_composite_key_support=, :primary_key=
-      def primary_key=(keys)
-        unless keys.kind_of?(Array)
-          self.primary_key_without_composite_key_support = keys
-          return
-        end
-
-        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
-
-        class_eval <<-EOV
-          extend  CompositeClassMethods
-          include CompositeInstanceMethods
-        EOV
-      end
-      alias_method :primary_keys=, :primary_key=
-
-      def set_primary_keys(*keys)
-        ActiveSupport::Deprecation.warn(
-            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
-        )
-
-        keys = keys.first if keys.first.is_a?(Array)
-        if keys.length == 1
-          self.primary_key = keys.first
-        else
-          self.primary_keys = keys
-        end
-      end
-
-      def composite?
-        false
-      end
-    end
-
-    def composite?
-      self.class.composite?
-    end
-
-    module CompositeClassMethods
-      def primary_keys
-        @primary_keys = reset_primary_keys unless defined? @primary_keys
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys #:nodoc:
-        if self == base_class
-          # CPK
-          self.primary_keys = get_primary_key(base_class.name)
-        else
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key
-        primary_keys
-      end
-
-      def primary_key=(keys)
-        self.primary_keys = keys
-      end
-
-      def composite?
-        true
-      end
-
-      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
-      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
-      end
-    end
-
-    module CompositeInstanceMethods
-      # A model instance's primary keys is always available as model.ids
-      # whether you name it the default 'id' or set it to something else.
-      def id
-        attr_names = self.class.primary_keys
-        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
-      end
-      alias_method :ids, :id
-
-      # This is overridden purely for json serialization support. If the model is composite
-      # and one of the keys is id, then we don't want to call the id method, instead we want
-      # to get the id attribute value
-      def read_attribute_for_serialization(attribute)
-        if self.composite? && attribute == 'id'
-          read_attribute(attribute)
-        else
-          send(attribute)
-        end
-      end
-
-      def ids_hash
-        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
-          hash[key] = value
-          hash
-        end
-      end
-
-      def id_before_type_cast
-        self.class.primary_keys.map do |key|
-          self.read_attribute_before_type_cast(key)
-        end
-      end
-
-      # Sets the primary ID.
-      def id=(ids)
-        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
-        unless ids.length == self.class.primary_keys.length
-          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
-        end
-        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
-        id
-      end
-
-      def can_change_primary_key_values?
-        false
-      end
-
-      # Returns this record's primary keys values in an Array
-      # if any value is available
-      def to_key
-        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
-      end
-
-      def to_param
-        persisted? ? to_key.to_composite_keys.to_s : nil
-      end
-    end
-  end
-end
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
+
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
+    class << self
+      alias_method :primary_key_without_composite_key_support=, :primary_key=
+      def primary_key=(keys)
+        unless keys.kind_of?(Array)
+          self.primary_key_without_composite_key_support = keys
+          return
+        end
+
+        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
+
+        class_eval <<-EOV
+          extend  CompositeClassMethods
+          include CompositeInstanceMethods
+        EOV
+      end
+      alias_method :primary_keys=, :primary_key=
+
+      def set_primary_keys(*keys)
+        ActiveSupport::Deprecation.warn(
+            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
+        )
+
+        keys = keys.first if keys.first.is_a?(Array)
+        if keys.length == 1
+          self.primary_key = keys.first
+        else
+          self.primary_keys = keys
+        end
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    def composite?
+      self.class.composite?
+    end
+
+    module CompositeClassMethods
+      def primary_keys
+        @primary_keys = reset_primary_keys unless defined? @primary_keys
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys #:nodoc:
+        if self == base_class
+          # CPK
+          self.primary_keys = get_primary_key(base_class.name)
+        else
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
+      def primary_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        self.primary_keys = keys
+      end
+
+      def composite?
+        true
+      end
+
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
+      end
+    end
+
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
+
+      # This is overridden purely for json serialization support. If the model is composite
+      # and one of the keys is id, then we don't want to call the id method, instead we want
+      # to get the id attribute value
+      def read_attribute_for_serialization(attribute)
+        if self.composite? && attribute == 'id'
+          read_attribute(attribute)
+        else
+          send(attribute)
+        end
+      end
+
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+
+      def id_before_type_cast
+        self.class.primary_keys.map do |key|
+          self.read_attribute_before_type_cast(key)
+        end
+      end
+
+      # Sets the primary ID.
+      def id=(ids)
+        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
+        unless ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
+        end
+        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
+
+      def can_change_primary_key_values?
+        false
+      end
+
+      # Returns this record's primary keys values in an Array
+      # if any value is available
+      def to_key
+        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_predicates.rb

@@ -62,6 +62,7 @@ end
 ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association::LoaderQuery.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::HasManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Base.send(:extend, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/persistence.rb

@@ -30,11 +30,18 @@ module ActiveRecord
           end
         end
 
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
 
-        um = arel_table.where(
-          constraints.reduce(&:and)
-        ).compile_update(_substitute_values(values), primary_key)
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        um = Arel::UpdateManager.new(arel_table)
+        um.set(values.transform_keys { |name| arel_table[name] })
+        um.wheres = constraints
 
         connection.update(um, "#{self} Update")
       end
@@ -48,10 +55,16 @@ module ActiveRecord
           end
         end
 
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
 
-        dm = Arel::DeleteManager.new
-        dm.from(arel_table)
+        dm = Arel::DeleteManager.new(arel_table)
         dm.wheres = constraints
 
         connection.delete(dm, "#{self} Destroy")
@@ -73,6 +86,7 @@ module ActiveRecord
       end
 
       @new_record = false
+      @previously_new_record = true
 
       yield(self) if block_given?
 

data/lib/composite_primary_keys/relation/calculations.rb

@@ -42,7 +42,13 @@ module CompositePrimaryKeys
 
         result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
 
-        type_cast_calculated_value(result.cast_values.first, operation) do |value|
+        if operation != "count"
+          type = column.try(:type_caster) ||
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type = type.subtype if ::ActiveRecord::Enum::EnumType === type
+        end
+
+        type_cast_calculated_value(result.cast_values.first, operation, type) do |value|
           type = column.try(:type_caster) ||
             # CPK
             # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
 module CompositePrimaryKeys
   module VERSION
-    MAJOR = 13
+    MAJOR = 14
     MINOR = 0
-    TINY  = 2
+    TINY  = 3
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/lib/composite_primary_keys.rb

@@ -23,7 +23,7 @@
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '~>6.1.0'
+  gem 'activerecord', '~>7.0.0', '>= 7.0.1'
   require 'active_record'
 end
 

data/test/abstract_unit.rb

@@ -1,4 +1,4 @@
-spec_name = ENV['ADAPTER'] || 'sqlite'
+spec_name = ENV['ADAPTER'] || 'postgresql'
 require 'bundler'
 require 'minitest/autorun'
 
@@ -21,6 +21,10 @@ ActiveRecord::Base.configurations = {test: spec}
 
 # Tell ActiveRecord where to find models
 ActiveSupport::Dependencies.autoload_paths << File.join(PROJECT_ROOT, 'test', 'fixtures')
+Dir[File.join(PROJECT_ROOT, 'test', 'fixtures', '*.rb')].each do |file_path|
+  require_file = file_path.sub(PROJECT_ROOT, '..').sub('.rb', '')
+  require_relative require_file
+end
 
 I18n.config.enforce_available_locales = true
 

data/test/test_associations.rb

@@ -343,7 +343,7 @@ class TestAssociations < ActiveSupport::TestCase
     assert_equal([3,2], memberships[1].id)
   end
 
-  def test_join_constraints
+  def test_scoped_has_many_with_primary_key_with_associations
     memberships = Membership.joins(:active_statuses)
     assert_equal(2, memberships.length)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 13.0.2
+  version: 14.0.3
 platform: ruby
 authors:
 - Charlie Savage
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.1.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -209,7 +209,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="