composite_primary_keys 14.0.6 → 14.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76a010358e1d2cacd9b05f6229c1fe4225f20f888fefb57b0bd6a9f62589a720
-  data.tar.gz: 1b7870c774bbed21d4556cf53518054860903cae4a0987f5978e02fc3883597f
+  metadata.gz: 717baef11c50b8c166a79ddb4c024c5c9bb1665062381125a338ad11f1d87fc0
+  data.tar.gz: dfb9f5b2cba6bb0f95a2f27126eba9b08a24eb3189ca7abcdfed98e30464e39d
 SHA512:
-  metadata.gz: 117d7be0b54619f7adcb05ddb200c3c97571cc74bf2fcf33c99034efaec08924cf6d56e998db1135c92bf71497697b30ca531a882d755329d5b6f9192d606013
-  data.tar.gz: a9f330398e5b1a9153a67f229a28e83d65c5bc02334e6e9f3456229c4c1e011a3bf03909fa45e37739d4ab47a37663a3ee6ef09c7d7194721e91849e520c0a01
+  metadata.gz: 4561141fc8ecbd420dbeb2e0e0c8b28c77cd8f2156e0bcf073776b17dd9cb3c9b5703ae159791c151973668aa6cfd46547501201a818a78ffcb553abf498a58f
+  data.tar.gz: c9bec41adfcd267e6b728831b7668b0634a69edaf5a84785a0ec2c1d77f1892b09c7e5044416aac66cdc9039a46e09cc1e855e28c70e182fbc2bf287cf71623c

data/History.rdoc

@@ -1,3 +1,13 @@
+== 14.0.8 (2023-11-24)
+* Support polymorphic_name (Vladimir Kochnev)
+* Fix HasOneThrough association (kyori19)
+
+== 14.0.7 (2023-11-04)
+* Add support for Trilogy Adapter (Zack Mariscal)
+* Add Dockerfile and Docker compose support (Zack Mariscal)
+* Support polymorphic_name (Vladimir Kochnev)
+* Fix HasOneThrough association (kyori19)
+
 == 14.0.6 (2023-02-04)
 * Port fix for #573 (Charlie Savage)
 * Port fix for fix #577 (Charlie Savage)
@@ -31,6 +41,9 @@ more frequently. (Andrew Kiellor)
 == 14.0.0 (2022-01-9)
 * Update to ActiveRecord 7.0 (Sammy Larbi)
 
+==13.0.8 (2023-11-24)
+Fix ‘polymorphic_name` support (Vladimir Kochnev)
+
 == 13.0.7 (2023-02-04)
 * Fix #573 (Charlie Savage)
 

data/README.rdoc

@@ -1,182 +1,182 @@
-= Composite Primary Keys for ActiveRecords
-
-== Summary
-
-ActiveRecord infamously doesn't support composite primary keys.
-This gem, composite_primary_keys, or CPK for short, extends ActiveRecord
-to support composite keys.
-
-== Installation
-
-    gem install composite_primary_keys
-
-If you are using Rails add the following to your Gemfile:
-
-  gem 'composite_primary_keys', '=x.x.x' (see next section about what version to use)
-
-== Versions
-
-Every major version of ActiveRecord has included numerous internal changes.  As a result,
-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
-    Version 10.x is designed to work with ActiveRecord 5.1.x
-    Version  9.x is designed to work with ActiveRecord 5.0.x
-    Version  8.x is designed to work with ActiveRecord 4.2.x
-    Version  7.x is designed to work with ActiveRecord 4.1.x
-    Version  6.x is designed to work with ActiveRecord 4.0.x
-    Version  5.x is designed to work with ActiveRecord 3.2.x
-    Version  4.x is designed to work with ActiveRecord 3.1.x
-
-Run the following command to list available versions:
-
-    gem list composite_primary_keys -ra
-
-== The basics
-
-A model with composite primary keys is defined like this:
-
-  class Membership < ActiveRecord::Base
-    self.primary_keys = :user_id, :group_id
-    belongs_to :user
-    belongs_to :group
-    has_many :statuses, :class_name => 'MembershipStatus', :foreign_key => [:user_id, :group_id]
-  end
-
-Note the addition of the line:
-
-    self.primary_keys = :user_id, :group_id
-
-
-A model associated with a composite key model is defined like this:
-
-  class MembershipStatus < ActiveRecord::Base
-    belongs_to :membership, :foreign_key => [:user_id, :group_id]
-  end
-
-That is, associations can include composite keys too.  All Rails association types are supported. Nice.
-
-== Usage
-
-Once you’ve created your models to specify composite primary keys (such as the Membership class)
-and associations (such as MembershipStatus#membership), you can use them like any normal model
-with associations.
-
-But first, lets check out our primary keys.
-
-  MembershipStatus.primary_key # => "id"    # normal single key
-  Membership.primary_key  # => [:user_id, :group_id] # composite keys
-  Membership.primary_key.to_s # => "user_id,group_id"
-
-Now we want to be able to find instances using the same syntax we always use for ActiveRecords.
-
-  MembershipStatus.find(1)    # single id returns single instance
-  => <MembershipStatus:0x392a8c8 @attributes={"id"=>"1", "status"=>"Active"}>
-
-  Membership.find([1,1])  # composite ids returns single instance
-  => <Membership:0x39218b0 @attributes={"user_id"=>"1", "group_id"=>"1"}>
-
-Notice the use of an array to specify the composite key values.
-
-NOTE - API CHANGE.  CPK Version 6.x and earlier used to allow composite keys to be listed out
-like this:
-
-  Membership.find(1,1)
-
-This usage is no longer supported.
-
-== Databases
-
-CPK supports the following databases:
-
- * PostgreSQL
- * MySQL
- * MariaDB
- * Oracle
- * DB2
- * SQLite
- * SQLServer
-
-== Tests
-
-To run tests you first need to install the appropriate gems for the database you want to test.  Database gems are
-divided into the following bundler groups:
-
- * mysql
- * oracle
- * postgresql
- * sqlite
- * sqlserver
-
-Since it is likely you do not have all the above databases installed on your computer, you want to install just the
-gems for your database.  For example, to test postgresql you would install the appropriate gems like this:
-
-  bundler config set --local without "mysql oracle sqlite sqlserver"
-  bundler install
-
-Once you have installed the appropriate gems, the next step is to create the test database. There is a rake
-command for each database. Using our example:
-
-  rake postgresql:build_database
-
-You can also rebuild the database if it already exists using this command:
-
-  rake postgresql:rebuild_database
-
-To get a list of commands for your database use:
-
-  Rake -T
-
-Finally, to run tests:
-
-  rake postgresql:test
-
-Travis build status: {<img src="https://travis-ci.com/composite-primary-keys/composite_primary_keys.svg" alt="Build Status" />}[https://travis-ci.com/composite-primary-keys/composite_primary_keys]
-
-=== DB2
-
-DB2 is no longer supported due to difficulties in getting the ibm_db2 gem to build.  Thus tests
-have not been run against db2.
-
-=== MariaDb (mysql)
-
-MariaDb is fully supported with all tests passing.
-
-=== Oracle
-
-Oracle is fully supported with all tests passing.
-
-=== Postgresql
-
-Postgresql is fully supported with all tests passing.
-
-=== Sqlite 3
-
-The sqlite database is created at the path composite_primary_keys/db.  Note you must *first* create the database using the
-built-in rake task before running tests:
-
-  rake sqlite:build_database
-
-For sqlite3 to work correctly, you must manually require 'composite_primary_keys/connection_adapters/sqlite3_adapter' after
-loading the CPK gem.
-
-=== SqlServer
-
-SqlServer is partially supported.  There are a number of failing tests - patches welcomed.
-
-== Questions, Discussion and Contributions
-
-For help please visit https://github.com/composite-primary-keys/composite_primary_keys.
-
-== Author
-
-First version was written by Dr Nic Williams.
-
-Maintained by Charlie Savage
-
-Contributions by many!
-
+= Composite Primary Keys for ActiveRecords
+
+== Summary
+
+ActiveRecord infamously doesn't support composite primary keys.
+This gem, composite_primary_keys, or CPK for short, extends ActiveRecord
+to support composite keys.
+
+== Installation
+
+    gem install composite_primary_keys
+
+If you are using Rails add the following to your Gemfile:
+
+  gem 'composite_primary_keys', '=x.x.x' (see next section about what version to use)
+
+== Versions
+
+Every major version of ActiveRecord has included numerous internal changes.  As a result,
+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
+    Version 10.x is designed to work with ActiveRecord 5.1.x
+    Version  9.x is designed to work with ActiveRecord 5.0.x
+    Version  8.x is designed to work with ActiveRecord 4.2.x
+    Version  7.x is designed to work with ActiveRecord 4.1.x
+    Version  6.x is designed to work with ActiveRecord 4.0.x
+    Version  5.x is designed to work with ActiveRecord 3.2.x
+    Version  4.x is designed to work with ActiveRecord 3.1.x
+
+Run the following command to list available versions:
+
+    gem list composite_primary_keys -ra
+
+== The basics
+
+A model with composite primary keys is defined like this:
+
+  class Membership < ActiveRecord::Base
+    self.primary_keys = :user_id, :group_id
+    belongs_to :user
+    belongs_to :group
+    has_many :statuses, :class_name => 'MembershipStatus', :foreign_key => [:user_id, :group_id]
+  end
+
+Note the addition of the line:
+
+    self.primary_keys = :user_id, :group_id
+
+
+A model associated with a composite key model is defined like this:
+
+  class MembershipStatus < ActiveRecord::Base
+    belongs_to :membership, :foreign_key => [:user_id, :group_id]
+  end
+
+That is, associations can include composite keys too.  All Rails association types are supported. Nice.
+
+== Usage
+
+Once you’ve created your models to specify composite primary keys (such as the Membership class)
+and associations (such as MembershipStatus#membership), you can use them like any normal model
+with associations.
+
+But first, lets check out our primary keys.
+
+  MembershipStatus.primary_key # => "id"    # normal single key
+  Membership.primary_key  # => [:user_id, :group_id] # composite keys
+  Membership.primary_key.to_s # => "user_id,group_id"
+
+Now we want to be able to find instances using the same syntax we always use for ActiveRecords.
+
+  MembershipStatus.find(1)    # single id returns single instance
+  => <MembershipStatus:0x392a8c8 @attributes={"id"=>"1", "status"=>"Active"}>
+
+  Membership.find([1,1])  # composite ids returns single instance
+  => <Membership:0x39218b0 @attributes={"user_id"=>"1", "group_id"=>"1"}>
+
+Notice the use of an array to specify the composite key values.
+
+NOTE - API CHANGE.  CPK Version 6.x and earlier used to allow composite keys to be listed out
+like this:
+
+  Membership.find(1,1)
+
+This usage is no longer supported.
+
+== Databases
+
+CPK supports the following databases:
+
+ * PostgreSQL
+ * MySQL
+ * MariaDB
+ * Oracle
+ * DB2
+ * SQLite
+ * SQLServer
+
+== Tests
+
+To run tests you first need to install the appropriate gems for the database you want to test.  Database gems are
+divided into the following bundler groups:
+
+ * mysql
+ * oracle
+ * postgresql
+ * sqlite
+ * sqlserver
+
+Since it is likely you do not have all the above databases installed on your computer, you want to install just the
+gems for your database.  For example, to test postgresql you would install the appropriate gems like this:
+
+  bundler config set --local without "mysql oracle sqlite sqlserver"
+  bundler install
+
+Once you have installed the appropriate gems, the next step is to create the test database. There is a rake
+command for each database. Using our example:
+
+  rake postgresql:build_database
+
+You can also rebuild the database if it already exists using this command:
+
+  rake postgresql:rebuild_database
+
+To get a list of commands for your database use:
+
+  Rake -T
+
+Finally, to run tests:
+
+  rake postgresql:test
+
+Travis build status: {<img src="https://travis-ci.com/composite-primary-keys/composite_primary_keys.svg" alt="Build Status" />}[https://travis-ci.com/composite-primary-keys/composite_primary_keys]
+
+=== DB2
+
+DB2 is no longer supported due to difficulties in getting the ibm_db2 gem to build.  Thus tests
+have not been run against db2.
+
+=== MariaDb (mysql)
+
+MariaDb is fully supported with all tests passing.
+
+=== Oracle
+
+Oracle is fully supported with all tests passing.
+
+=== Postgresql
+
+Postgresql is fully supported with all tests passing.
+
+=== Sqlite 3
+
+The sqlite database is created at the path composite_primary_keys/db.  Note you must *first* create the database using the
+built-in rake task before running tests:
+
+  rake sqlite:build_database
+
+For sqlite3 to work correctly, you must manually require 'composite_primary_keys/connection_adapters/sqlite3_adapter' after
+loading the CPK gem.
+
+=== SqlServer
+
+SqlServer is partially supported.  There are a number of failing tests - patches welcomed.
+
+== Questions, Discussion and Contributions
+
+For help please visit https://github.com/composite-primary-keys/composite_primary_keys.
+
+== Author
+
+First version was written by Dr Nic Williams.
+
+Maintained by Charlie Savage
+
+Contributions by many!
+

data/Rakefile

@@ -23,7 +23,7 @@ Dir.glob('tasks/**/*.rake').each do |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|
+%w(mysql sqlite oracle oracle_enhanced postgresql ibm_db sqlserver trilogy).each do |adapter|
   namespace adapter do
     desc "Run tests using the #{adapter} adapter"
     task "test" do

data/lib/composite_primary_keys/associations/association.rb

@@ -11,8 +11,8 @@ module ActiveRecord
             attributes[key1] = owner[key2]
           end
 
-          if reflection.options[:as]
-            attributes[reflection.type] = owner.class.base_class.name
+          if reflection.type
+            attributes[reflection.type] = owner.class.polymorphic_name
           end
         end
 

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -64,4 +64,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -1,39 +1,39 @@
-module CompositePrimaryKeys
-  module CollectionAssociation
-    def ids_writer(ids)
-      primary_key = reflection.association_primary_key
-      ids = Array(ids).reject(&:blank?)
-
-      # CPK-
-      if primary_key.is_a?(Array)
-        ids = ids.map { |id| CompositePrimaryKeys::CompositeKeys.parse(id) }
-        primary_key.each_with_index do |key, i|
-          pk_type = klass.type_for_attribute(key)
-          ids.each { |id| id[i] = pk_type.cast(id[i]) }
-        end
-
-        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).compact
-      else
-        pk_type = klass.type_for_attribute(primary_key)
-        ids.map! { |i| pk_type.cast(i) }
-
-        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
+      ids = Array(ids).reject(&:blank?)
+
+      # CPK-
+      if primary_key.is_a?(Array)
+        ids = ids.map { |id| CompositePrimaryKeys::CompositeKeys.parse(id) }
+        primary_key.each_with_index do |key, i|
+          pk_type = klass.type_for_attribute(key)
+          ids.each { |id| id[i] = pk_type.cast(id[i]) }
+        end
+
+        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).compact
+      else
+        pk_type = klass.type_for_attribute(primary_key)
+        ids.map! { |i| pk_type.cast(i) }
+
+        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/has_many_through_association.rb

@@ -23,6 +23,25 @@ module ActiveRecord
           end
         end
       end
+
+      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/associations/preloader/association.rb

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