composite_primary_keys 13.0.1 → 14.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9e6df76c33e6eae43b2be918772faba1bfaceaeb2849deedce615f94d6c84bd
-  data.tar.gz: cd28e3d91fea6190f64fe43a52eaea23fdd25ff601cfdf9fd4268cb361d98e1c
+  metadata.gz: 4310258f29b867cf484cb8dbebfe1f7a7d41810f2dac5f90049c534f1c0a908b
+  data.tar.gz: 970906ceae8ac95925d5ee694541b09844f3104309eaed5864f9b1faff7fb43e
 SHA512:
-  metadata.gz: '093c59b0bdbd0281194cd28bc70101b26c3402bb13ef7fa3fe1e60f865f2423dbe90f39a669a833173a19cc129c5457476d5233f6cdaf0a7a1859cb1d3b7e36c'
-  data.tar.gz: 9e08a5afafe648410b7a2eecf3190959300a27baf57e93da0988853862a851ef28e5a655032f3b1236b55d39c435f3b71721abad0740cdf136bdd0d7c66439b1
+  metadata.gz: 78878c2b2fa9612e8e141b5b1d39679a03046aed63e7c19e7ad71b6b8372327cfcb9a5bb659d88fda5cbb405e5bf7199c742b0468041a9509406ce54764d4e10
+  data.tar.gz: 79e78cb7cf9a336821cb02dad8d1cf43aece81e25b18c4ebadac1b584be1d6bd06a7a43b7840c918323efb69d8b0c9783c215595f04a37dc083079ba4e0cc50e

data/History.rdoc

@@ -1,9 +1,15 @@
-== 13.0.1
+== 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.1 (2021-11-14)
 * Fix invalid sql generation for some cases of scoped associations (Ryan Mulligan)
 * Fix unintentional connection to database (Kazuhiro Masuda)
 * Zip values then keys - fixes #548 (Charlie Savage)
 
-== 13.0.0
+== 13.0.0 (2021-5-9)
 * Update to ActiveRecord 6.1 (Javier Julio, Charlie Savage, Sammy Larbi)
 
 == 12.0.10 (2021-05-09)

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/Rakefile

@@ -1,37 +1,37 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rubygems/package_task'
-
-# Set global variable so other tasks can access them
-::PROJECT_ROOT = File.expand_path(".")
-::GEM_NAME = 'composite_primary_keys'
-
-require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
-require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
-
-# Read the spec file
-spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
-
-# Setup Rake tasks for managing the gem
-Gem::PackageTask.new(spec).define
-
-# Now load in other task files
-Dir.glob('tasks/**/*.rake').each do |rake_file|
-  load File.join(File.dirname(__FILE__), rake_file)
-end
-
-# Set up test tasks for each supported connection adapter
-%w(mysql sqlite oracle oracle_enhanced postgresql ibm_db sqlserver).each do |adapter|
-  namespace adapter do
-    desc "Run tests using the #{adapter} adapter"
-    task "test" do
-      ENV["ADAPTER"] = adapter
-      Rake::TestTask.new("subtest_#{adapter}") do |t|
-        t.libs << "test"
-      end
-      Rake::Task["subtest_#{adapter}"].invoke
-    end
-  end
-end
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+# Set global variable so other tasks can access them
+::PROJECT_ROOT = File.expand_path(".")
+::GEM_NAME = 'composite_primary_keys'
+
+require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
+require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
+
+# Read the spec file
+spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
+
+# Setup Rake tasks for managing the gem
+Gem::PackageTask.new(spec).define
+
+# Now load in other task files
+Dir.glob('tasks/**/*.rake').each do |rake_file|
+  load File.join(File.dirname(__FILE__), rake_file)
+end
+
+# Set up test tasks for each supported connection adapter
+%w(mysql sqlite oracle oracle_enhanced postgresql ibm_db sqlserver).each do |adapter|
+  namespace adapter do
+    desc "Run tests using the #{adapter} adapter"
+    task "test" do
+      ENV["ADAPTER"] = adapter
+      Rake::TestTask.new("subtest_#{adapter}") do |t|
+        t.libs << "test"
+      end
+      Rake::Task["subtest_#{adapter}"].invoke
+    end
+  end
+end

data/lib/composite_primary_keys/arel/sqlserver.rb

@@ -1,37 +1,37 @@
-module Arel
-  module Visitors
-    class SQLServer < Arel::Visitors::ToSql
-      def make_Fetch_Possible_And_Deterministic o
-        return if o.limit.nil? && o.offset.nil?
-        t = table_From_Statement o
-        pk = primary_Key_From_Table t
-        return unless pk
-        if o.orders.empty?
-          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
-          # CPK
-          #o.orders = [pk.asc]
-          o.orders = pk.map {|a_pk| a_pk.asc}
-        end
-      end
-
-      def primary_Key_From_Table t
-        return unless t
-        column_name = @connection.schema_cache.primary_keys(t.name) ||
-          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
-
-        # CPK
-        # column_name ? t[column_name] : nil
-        case column_name
-          when Array
-            column_name.map do |name|
-              t[name]
-            end
-          when NilClass
-            nil
-          else
-            [t[column_name]]
-        end
-      end
-    end
-  end
-end
+module Arel
+  module Visitors
+    class SQLServer < Arel::Visitors::ToSql
+      def make_Fetch_Possible_And_Deterministic o
+        return if o.limit.nil? && o.offset.nil?
+        t = table_From_Statement o
+        pk = primary_Key_From_Table t
+        return unless pk
+        if o.orders.empty?
+          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
+          # CPK
+          #o.orders = [pk.asc]
+          o.orders = pk.map {|a_pk| a_pk.asc}
+        end
+      end
+
+      def primary_Key_From_Table t
+        return unless t
+        column_name = @connection.schema_cache.primary_keys(t.name) ||
+          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+
+        # CPK
+        # column_name ? t[column_name] : nil
+        case column_name
+          when Array
+            column_name.map do |name|
+              t[name]
+            end
+          when NilClass
+            nil
+          else
+            [t[column_name]]
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/arel/to_sql.rb

@@ -1,18 +1,18 @@
-module Arel
-  module Visitors
-    class ToSql
-      def visit_CompositePrimaryKeys_CompositeKeys o, collector
-        values = o.map do |key|
-          case key
-            when Arel::Attributes::Attribute
-              "#{key.relation.name}.#{key.name}"
-            else
-              key
-          end
-        end
-        collector << "(#{values.join(', ')})"
-        collector
-      end
-    end
-  end
-end
+module Arel
+  module Visitors
+    class ToSql
+      def visit_CompositePrimaryKeys_CompositeKeys o, collector
+        values = o.map do |key|
+          case key
+            when Arel::Attributes::Attribute
+              "#{key.relation.name}.#{key.name}"
+            else
+              key
+          end
+        end
+        collector << "(#{values.join(', ')})"
+        collector
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association.rb

@@ -1,23 +1,23 @@
-module ActiveRecord
-  module Associations
-    class Association
-      def creation_attributes
-        attributes = {}
-
-        if (reflection.has_one? || reflection.collection?) && !options[:through]
-          # CPK
-          # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
-          Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
-            attributes[key1] = owner[key2]
-          end
-
-          if reflection.options[:as]
-            attributes[reflection.type] = owner.class.base_class.name
-          end
-        end
-
-        attributes
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Association
+      def creation_attributes
+        attributes = {}
+
+        if (reflection.has_one? || reflection.collection?) && !options[:through]
+          # CPK
+          # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+          Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
+            attributes[key1] = owner[key2]
+          end
+
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.class.base_class.name
+          end
+        end
+
+        attributes
+      end
+    end
+  end
+end

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/preloader/association.rb

@@ -1,53 +1,68 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class Association
-        def records_for(ids)
-          records = if association_key_name.is_a?(Array)
-                      predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
-                      scope.where(predicate)
-                    else
-                      scope.where(association_key_name => ids)
-                    end
-          records.load do |record|
-            # Processing only the first owner
-            # because the record is modified but not an owner
-            owner = owners_by_key[convert_key(record[association_key_name])].first
-            association = owner.association(reflection.name)
-            association.set_inverse_instance(record)
-          end
-        end
-
-        def owners_by_key
-          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
-            # CPK
-            # key = convert_key(owner[owner_key_name])
-            key = if owner_key_name.is_a?(Array)
-                    Array(owner_key_name).map do |key_name|
-                      convert_key(owner[key_name])
-                    end
-                  else
-                    convert_key(owner[owner_key_name])
-                  end
-            (result[key] ||= []) << owner if key
-          end
-        end
-
-        def records_by_owner
-          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
-            key = if association_key_name.is_a?(Array)
-                    Array(record[association_key_name]).map do |key|
-                      convert_key(key)
-                    end
-                  else
-                    convert_key(record[association_key_name])
-                  end
-            owners_by_key[key].each do |owner|
-              (result[owner] ||= []) << record
-            end
-          end
-        end
-      end
-    end
-  end
-end
+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)
+                      scope.where(predicate)
+                    else
+                      scope.where(association_key_name => ids)
+                    end
+          records.load do |record|
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            owner = owners_by_key[convert_key(record[association_key_name])].first
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            # CPK
+            # key = convert_key(owner[owner_key_name])
+            key = if owner_key_name.is_a?(Array)
+                    Array(owner_key_name).map do |key_name|
+                      convert_key(owner[key_name])
+                    end
+                  else
+                    convert_key(owner[owner_key_name])
+                  end
+            (result[key] ||= []) << owner if key
+          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)
+                    Array(record[association_key_name]).map do |key|
+                      convert_key(key)
+                    end
+                  else
+                    convert_key(record[association_key_name])
+                  end
+            owners_by_key[key].each do |owner|
+              (result[owner] ||= []) << record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/through_association.rb

@@ -1,25 +1,25 @@
-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
+        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