composite_primary_keys 14.0.8 → 14.0.10

data/lib/composite_primary_keys/core.rb

@@ -1,49 +1,72 @@
-module ActiveRecord
-  module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      # CPK
-      #@attributes.reset(@primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
-
-      _run_initialize_callbacks
-
-      @new_record               = true
-      @destroyed                = false
-      @_start_transaction_state = nil
-      @transaction_state        = nil
-
-      super
-    end
-
-    module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        return super if block_given? ||
-            primary_key.nil? ||
-            scope_attributes? ||
-            columns_hash.key?(inheritance_column) && !base_class?
-
-        # CPK
-        return super if self.composite?
-
-        id = ids.first
-
-        return super if StatementCache.unsupported_value?(id)
-
-        key = primary_key
-
-        statement = cached_find_by_statement(key) { |params|
-          where(key => params.bind).limit(1)
-        }
-
-        record = statement.execute([id], connection)&.first
-        unless record
-          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
-        end
-        record
-      end
-    end
-  end
+module ActiveRecord
+  module Core
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      # CPK
+      #@attributes.reset(@primary_key)
+      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+
+      _run_initialize_callbacks
+
+      @new_record               = true
+      @destroyed                = false
+      @_start_transaction_state = nil
+      @transaction_state        = nil
+
+      super
+    end
+
+    def primary_key_values_present?
+      if self.composite?
+        id.all? {|key| !key.nil?}
+      else
+        !id.nil?
+      end
+    end
+
+    def ==(comparison_object)
+      super ||
+        comparison_object.instance_of?(self.class) &&
+        primary_key_values_present? &&
+        comparison_object.id == id
+    end
+
+    def hash
+      if primary_key_values_present?
+        self.class.hash ^ id.hash
+      else
+        super
+      end
+    end
+
+    module ClassMethods
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        return super if block_given? ||
+            primary_key.nil? ||
+            scope_attributes? ||
+            columns_hash.key?(inheritance_column) && !base_class?
+
+        # CPK
+        return super if self.composite?
+
+        id = ids.first
+
+        return super if StatementCache.unsupported_value?(id)
+
+        key = primary_key
+
+        statement = cached_find_by_statement(key) { |params|
+          where(key => params.bind).limit(1)
+        }
+
+        record = statement.execute([id], connection)&.first
+        unless record
+          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
+        end
+        record
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -61,12 +61,12 @@ module ActiveRecord
           unless reject_new_record?(association_name, attributes)
             association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
-        elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+        elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
           unless call_reject_if(association_name, attributes)
             # Make sure we are operating on the actual object which is in the association's
             # proxy_target array (either by finding it, or adding it if not found)
             # Take into account that the proxy_target may have changed due to callbacks
-            target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+            target_record = cpk_detect_record(attributes['id'], association.target)
             if target_record
               existing_record = target_record
             else

data/lib/composite_primary_keys/persistence.rb

@@ -1,96 +1,96 @@
-module ActiveRecord
-  module Persistence
-    module ClassMethods
-      def delete(id_or_array)
-        # CPK
-        if self.composite?
-          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
-                          [id_or_array]
-                        else
-                          Array(id_or_array)
-                        end
-
-          # Delete should return the number of deleted records
-          id_or_array.map do |id|
-            # Is the passed in id actually a record?
-            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
-          end.sum
-        else
-          delete_by(primary_key => id_or_array)
-        end
-      end
-
-      def _update_record(values, constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-           constraints[key] = primary_key_values[i]
-          end
-        end
-
-        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
-
-        um = Arel::UpdateManager.new(arel_table)
-        um.set(values.transform_keys { |name| arel_table[name] })
-        um.wheres = constraints
-
-        connection.update(um, "#{self} Update")
-      end
-
-      def _delete_record(constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-            constraints[key] = primary_key_values[i]
-          end
-        end
-
-        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(arel_table)
-        dm.wheres = constraints
-
-        connection.delete(dm, "#{self} Destroy")
-      end
-    end
-
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
-
-      new_id = self.class._insert_record(
-          attributes_with_values(attribute_names)
-      )
-
-      # CPK
-      if self.composite?
-        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
-      else
-        self.id ||= new_id if self.class.primary_key
-      end
-
-      @new_record = false
-      @previously_new_record = true
-
-      yield(self) if block_given?
-
-      id
-    end
-  end
-end
+module ActiveRecord
+  module Persistence
+    module ClassMethods
+      def delete(id_or_array)
+        # CPK
+        if self.composite?
+          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
+                          [id_or_array]
+                        else
+                          Array(id_or_array)
+                        end
+
+          # Delete should return the number of deleted records
+          id_or_array.map do |id|
+            # Is the passed in id actually a record?
+            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
+          end.sum
+        else
+          delete_by(primary_key => id_or_array)
+        end
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+           constraints[key] = primary_key_values[i]
+          end
+        end
+
+        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
+
+        um = Arel::UpdateManager.new(arel_table)
+        um.set(values.transform_keys { |name| arel_table[name] })
+        um.wheres = constraints
+
+        connection.update(um, "#{self} Update")
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+            constraints[key] = primary_key_values[i]
+          end
+        end
+
+        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(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
+      end
+    end
+
+    def _create_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+          attributes_with_values(attribute_names)
+      )
+
+      # CPK
+      if self.composite?
+        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
+      else
+        self.id ||= new_id if self.class.primary_key
+      end
+
+      @new_record = false
+      @previously_new_record = true
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -1,91 +1,93 @@
-module ActiveRecord
-  module Reflection
-    class AbstractReflection
-      def join_scope(table, foreign_table, foreign_klass)
-        predicate_builder = predicate_builder(table)
-        scope_chain_items = join_scopes(table, predicate_builder)
-        klass_scope       = klass_join_scope(table, predicate_builder)
-
-        key         = join_primary_key
-        foreign_key = join_foreign_key
-
-        # CPK
-        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-        klass_scope.where!(constraint)
-
-        if type
-          klass_scope.where!(type => foreign_klass.polymorphic_name)
-        end
-
-        if klass.finder_needs_type_condition?
-          klass_scope.where!(klass.send(:type_condition, table))
-        end
-
-        scope_chain_items.inject(klass_scope, &:merge!)
-      end
-    end
-
-    class AssociationReflection < MacroReflection
-      def foreign_key
-        # CPK
-        # @foreign_key ||= -(options[:foreign_key]&.to_s || derive_foreign_key)
-        @foreign_key ||= extract_keys(options[:foreign_key]) || derive_foreign_key
-      end
-
-      def association_foreign_key
-        # CPK
-        # @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
-        @association_foreign_key ||= extract_keys(options[:association_foreign_key]) || class_name.foreign_key
-      end
-
-      def active_record_primary_key
-        # CPK (Rails freezes the string returned in the expression that calculates PK here. But Rails uses the `-` method which is not available on Array for CPK, so we calculate it in one line and freeze it on the next)
-        # @active_record_primary_key ||= -(options[:primary_key]&.to_s || primary_key(active_record))
-        @active_record_primary_key ||= begin
-          pk = options[:primary_key] || primary_key(active_record)
-          pk.freeze
-        end
-      end
-
-      private
-
-      def extract_keys(keys)
-        case keys
-          when Array
-            keys.map { |k| k.to_s }
-          when NilClass
-            nil
-          else
-            keys.to_s
-        end
-      end
-    end
-
-    class BelongsToReflection < AssociationReflection
-      def association_primary_key(klass = nil)
-        if primary_key = options[:primary_key]
-          # CPK
-          # @association_primary_key ||= -primary_key.to_s
-          @association_primary_key ||= primary_key.freeze
-        else
-          primary_key(klass || self.klass)
-        end
-      end
-    end
-
-    class ThroughReflection < AbstractReflection #:nodoc:
-      def association_primary_key(klass = nil)
-        # Get the "actual" source reflection if the immediate source reflection has a
-        # source reflection itself
-        if primary_key = actual_source_reflection.options[:primary_key]
-          # CPK
-          # @association_primary_key ||= -primary_key.to_s
-          @association_primary_key ||= primary_key.freeze
-        else
-          primary_key(klass || self.klass)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Reflection
+    class AbstractReflection
+      def join_scope(table, foreign_table, foreign_klass)
+        predicate_builder = predicate_builder(table)
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        if type
+          klass_scope.where!(type => foreign_klass.polymorphic_name)
+        end
+
+        scope_chain_items.inject(klass_scope, &:merge!)
+
+        key         = join_primary_key
+        foreign_key = join_foreign_key
+
+        # CPK
+        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        klass_scope.where!(constraint)
+
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
+        klass_scope
+      end
+    end
+
+    class AssociationReflection < MacroReflection
+      def foreign_key
+        # CPK
+        # @foreign_key ||= -(options[:foreign_key]&.to_s || derive_foreign_key)
+        @foreign_key ||= extract_keys(options[:foreign_key]) || derive_foreign_key
+      end
+
+      def association_foreign_key
+        # CPK
+        # @association_foreign_key ||= -(options[:association_foreign_key]&.to_s || class_name.foreign_key)
+        @association_foreign_key ||= extract_keys(options[:association_foreign_key]) || class_name.foreign_key
+      end
+
+      def active_record_primary_key
+        # CPK (Rails freezes the string returned in the expression that calculates PK here. But Rails uses the `-` method which is not available on Array for CPK, so we calculate it in one line and freeze it on the next)
+        # @active_record_primary_key ||= -(options[:primary_key]&.to_s || primary_key(active_record))
+        @active_record_primary_key ||= begin
+          pk = options[:primary_key] || primary_key(active_record)
+          pk.freeze
+        end
+      end
+
+      private
+
+      def extract_keys(keys)
+        case keys
+          when Array
+            keys.map { |k| k.to_s }
+          when NilClass
+            nil
+          else
+            keys.to_s
+        end
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection
+      def association_primary_key(klass = nil)
+        if primary_key = options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
+
+    class ThroughReflection < AbstractReflection #:nodoc:
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        if primary_key = actual_source_reflection.options[:primary_key]
+          # CPK
+          # @association_primary_key ||= -primary_key.to_s
+          @association_primary_key ||= primary_key.freeze
+        else
+          primary_key(klass || self.klass)
+        end
+      end
+    end
+  end
+end