composite_primary_keys 9.0.10 → 10.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 133a4025b9fe7ee82617de7c3c34373d8f52d38d5e88c03ab742ebd954bf6064
-  data.tar.gz: 579e4d9e564e4c9e40f976d0d56b76533296c8f7e5b5ba925d7244141604fb08
+  metadata.gz: f506d34f44d88354550c10d7b79f38c206dfa739c9c903e59c888252db3ae9ed
+  data.tar.gz: 06e5788af10e07e0dbe785338aa35c8cce99df310a7e43d3605b1cefb0eaa0ac
 SHA512:
-  metadata.gz: 334933952b9a84db67746c48c074c38d197215fa607640e134bf7aedd564e122a0c809318fab4529e0ad5bd181081baa792395419b25a4b19149066122cdfdfc
-  data.tar.gz: 2820381f390429bbdf61b0a04434c0432faa88d2cffdb04c5cd74f9dfc26682893809531b2d4dc14b03620614bec0ce1a69e128624b6a511b5718b19e24c9970
+  metadata.gz: 83ec3b8f8f42e7a5c92f11c60cb86fdb8fd4bdc9e6a58f1f3305ffb5c9b6af9b2abaabcaa43eeaa2e40e19cddab4cad5d7e5501905643e7b4fad0749525ac0b7
+  data.tar.gz: d1a8bad2cdea8ff1eab3ba7d5c456d68f008583b26b6000a930f58d319842aa6b2a24e66d7d509bd531cce4852f062797b96e53c0f929ed8aa0c6a19d40621c2

data/History.rdoc

@@ -1,10 +1,36 @@
-== 9.0.10 (2018-06-24)
+== 10.0.5 (2018-06-24)
+* Fix in_batches (Urmo Rae)
 
-* Fix AR 5.0.7 (Jordan Owens)
+== 10.0.4 (2018-06-17)
+
+* Lock mysql2 gem to 0.4.x (Le Trung Kien)
+* Set inversion when using preload  (Le Trung Kien)
+* Fixes for AR 5.1.6 (Tim Morgan)
+
+== 10.0.3 (2018-02-25)
+
+* Require a minimum of activerecord version 5.1.5 (Tom Hughes)
+
+== 10.0.2 (2017-12-02)
+
+* Fix frozen string mutation for mysql (Sergey Sein)
+* Fix autosave for belongs_to associations (Fabian Mersch)
+* Require a minimum of activerecord version 5.1.4 (Charlie Savage)
 
-== 9.0.9 (2018-03-06)
+== 10.0.1 (2017-10-08)
 
-* Fix update statements that incorrectly pass NULL values for the primary key components (Sean Linsley)
+* Fixed an error that happened when a table attribute had the same name as the table (Taishi Kasuga)
+
+== 10.0.0 (2017-10-08)
+
+* Support ActiveRecord 5.1.x (Pinak Thakkar, Jordan Owens)
+* Fix Paper Trail compatibility (Sean Linsley)
+* Fix typo in Readme (Mike Gunderloy)
+* Improved sql server support (Artyom Nikolaev)
+
+== 9.0.10 (2018-06-24)
+
+* Fix AR 5.0.7 (Jordan Owens)
 
 == 9.0.8 (2017-10-11)
 

data/README.rdoc

@@ -12,7 +12,7 @@ to support composite keys.
 
 If you are using Rails add the following to your Gemfile:
 
-  gem 'composite_primary_keys', '=x.x.x' (see next section about what verison to use)
+  gem 'composite_primary_keys', '=x.x.x' (see next section about what version to use)
 
 == Versions
 
@@ -20,12 +20,13 @@ 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 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
+    Version 10.x is designed to work with ActiveRecord 5.1.x (note this is in progress)
+    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:
 
@@ -155,8 +156,8 @@ built-in rake task before running tests:
 
   rake sqlite:build_database
 
-Note not all tests currently pass on sqlite3.  These failures happen when trying to DELETE records where the query
-includes a JOIN.
+For sqlite3 to work correctly, you must manually require 'composite_primary_keys/connection_adapters/sqlite3_adapter' after
+loading the CPK gem.
 
 === SqlServer
 

data/lib/composite_primary_keys/arel/sqlserver.rb

@@ -16,7 +16,8 @@ module Arel
 
       def primary_Key_From_Table t
         return unless t
-        column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.second.try(:name)
+        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

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,7 +1,6 @@
 module ActiveRecord
   module Associations
     class AssociationScope
-
       def self.get_bind_values(owner, chain)
         binds = []
         last_reflection = chain.last
@@ -23,31 +22,29 @@ module ActiveRecord
         binds
       end
 
-      def last_chain_scope(scope, table, reflection, owner, association_klass)
-        join_keys = reflection.join_keys(association_klass)
+      def last_chain_scope(scope, table, reflection, owner)
+        join_keys = reflection.join_keys
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
         # CPK
-        #value = transform_value(owner[foreign_key])
-        #scope = scope.where(table.name => { key => value })
-        mappings = Array(key).zip(Array(foreign_key))
-        joins = mappings.reduce(Hash.new) do |hash, mapping|
-          hash[mapping.first] = transform_value(owner[mapping.last])
-          hash
+        # value = transform_value(owner[foreign_key])
+        # scope = apply_scope(scope, table, key, value)
+        Array(key).zip(Array(foreign_key)).each do |a_join_key, a_foreign_key|
+          value = transform_value(owner[a_foreign_key])
+          scope = apply_scope(scope, table, a_join_key, value)
         end
-        scope = scope.where(table.name => joins)
 
         if reflection.type
           polymorphic_type = transform_value(owner.class.base_class.name)
-          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+          scope = apply_scope(scope, table, reflection.type, polymorphic_type)
         end
 
         scope
       end
 
-      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-        join_keys = reflection.join_keys(association_klass)
+      def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+        join_keys = reflection.join_keys
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
@@ -57,11 +54,11 @@ module ActiveRecord
 
         if reflection.type
           value = transform_value(next_reflection.klass.base_class.name)
-          scope = scope.where(table.name => { reflection.type => value })
+          scope = apply_scope(scope, table, reflection.type, value)
         end
 
-        scope = scope.joins(join(foreign_table, constraint))
+        scope.joins!(join(foreign_table, constraint))
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -29,7 +29,7 @@ module CompositePrimaryKeys
       ids.map! { |i| pk_type.cast(i) }
       # CPK
       if reflection.association_primary_key.is_a?(Array)
-        predicate = Class.new.extend(CompositePrimaryKeys::Predicates).cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
+        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)

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -18,7 +18,7 @@ module ActiveRecord
       end
 
       silence_warnings do
-        def instantiate(result_set, aliases)
+        def instantiate(result_set, &block)
           primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
           seen = Hash.new { |i, object_id|
@@ -47,7 +47,7 @@ module ActiveRecord
                              primary_key ? row_hash[primary_key] : row_hash
                            end
 
-              parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
+              parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
               construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
             }
           end

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -3,9 +3,9 @@ module ActiveRecord
     class Preloader
       class Association
         silence_warnings do
-          def query_scope(ids)
+          def records_for(ids)
             # CPK
-            # scope.where(association_key.in(ids))
+            # scope.where(association_key_name => ids)
 
             if reflection.foreign_key.is_a?(Array)
               predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
@@ -43,6 +43,8 @@ module ActiveRecord
               records.each do |record, owner_key|
                 owners_map[owner_key].each do |owner|
                   records_by_owner[owner] << record
+                  association = owner.association(reflection.name)
+                  association.set_inverse_instance(record)
                 end
               end
             end

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module Associations
     class Preloader
       class BelongsTo
-        def query_scope(ids)
+        def records_for(ids)
           # CPK
           # scope.where(association_key.in(ids))
 
@@ -10,7 +10,7 @@ module ActiveRecord
             predicate = cpk_in_predicate(table, association_key_name, ids)
             scope.where(predicate)
           else
-            scope.where(association_key.in(ids))
+            scope.where(association_key_name => ids)
           end
         end
       end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -16,6 +16,19 @@ module ActiveRecord
           end
 
         end
+
+        def id_in_database
+          sync_with_transaction_state
+          # CPK
+          # attribute_in_database(self.class.primary_key)
+          if self.composite?
+            self.class.primary_keys.map do |key_attr|
+              attribute_in_database(key_attr)
+            end
+          else
+            attribute_in_database(self.class.primary_key)
+          end
+        end
       end
     end
   end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -2,6 +2,20 @@ module ActiveRecord
   module AttributeMethods
     module Write
       silence_warnings do
+        def write_attribute(attr_name, value)
+          name = if self.class.attribute_alias?(attr_name)
+            # CPK
+            # self.class.attribute_alias(attr_name).to_s
+            self.class.attribute_alias(attr_name)
+          else
+            # CPK
+            # attr_name.to_s
+            attr_name
+          end
+
+          write_attribute_with_type_cast(name, value, true)
+        end
+
         def write_attribute_with_type_cast(attr_name, value, should_type_cast)
           # CPK
           if attr_name.kind_of?(Array)

data/lib/composite_primary_keys/base.rb

@@ -47,15 +47,16 @@ module ActiveRecord
 
     module CompositeClassMethods
       def primary_keys
-        unless defined?(@primary_keys)
-          reset_primary_keys
-        end
+        @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
-        if self != base_class
+       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

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,5 +1,9 @@
 module CompositePrimaryKeys
   module Predicates
+    # Similar to module_function, but does not make instance methods private.
+    # https://idiosyncratic-ruby.com/8-self-improvement.html
+    extend self
+
     def cpk_and_predicate(predicates)
       if predicates.length == 1
         predicates.first

data/lib/composite_primary_keys/connection_adapters/postgresql/database_statements.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module DatabaseStatements
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
+          if pk.nil?
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          # CPK
+          # if pk = suppress_composite_primary_key(pk)
+          #  sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+          #end
+          # NOTE pk can be false.
+          if pk
+            sql = "#{sql} RETURNING #{quote_column_names(pk)}"
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/sqlserver_adapter.rb

@@ -7,7 +7,7 @@ module ActiveRecord
           # quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
           # sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
           quoted_pks = [pk].flatten.map {|pk| "INSERTED.#{SQLServer::Utils.extract_identifiers(pk).quoted}"}
-          sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{quoted_pks.join(", ")}"
+          sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{quoted_pks.join(", ")}"
         else
           "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
         end

data/lib/composite_primary_keys/core.rb

@@ -27,36 +27,33 @@ module ActiveRecord
           return super if block_given? ||
                           primary_key.nil? ||
                           scope_attributes? ||
-                          columns_hash.include?(inheritance_column) ||
-                          ids.first.kind_of?(Array)
+                          columns_hash.include?(inheritance_column)
+
           # CPK
           return super if self.composite?
 
-          id  = ids.first
-          if ActiveRecord::Base === id
-            id = id.id
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              You are passing an instance of ActiveRecord::Base to `find`.
-              Please pass the id of the object by calling `.id`
-            MSG
-          end
+          id = ids.first
+
+          return super if id.kind_of?(Array) ||
+                           id.is_a?(ActiveRecord::Base)
 
           key = primary_key
 
           statement = cached_find_by_statement(key) { |params|
             where(key => params.bind).limit(1)
           }
+
           record = statement.execute([id], self, connection).first
           unless record
             raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
                                      name, primary_key, id)
           end
           record
-        rescue RangeError
+        rescue ::RangeError
           raise RecordNotFound.new("Couldn't find #{name} with an out of range value for '#{primary_key}'",
                                    name, primary_key)
         end
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/locking/optimistic.rb

@@ -5,50 +5,40 @@ module ActiveRecord
       private
 
       silence_warnings do
-        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+        def _update_row(attribute_names, attempted_action = "update")
           return super unless locking_enabled?
-          return 0 if attribute_names.empty?
-
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          increment_lock
-
-          attribute_names += [lock_col]
-          attribute_names.uniq!
 
           begin
-            relation = self.class.unscoped
-
-            if self.composite?
-              affected_rows = relation.where(
-                  relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was)
-              ).where(
-                  lock_col => previous_lock_value
-              ).update_all(
-                  attributes_for_update(attribute_names).map do |name|
-                      [name, _read_attribute(name)]
-                  end.to_h
+            locking_column = self.class.locking_column
+            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            attribute_names << locking_column
+
+            self[locking_column] += 1
+
+            if composite?
+              affected_rows = self.class.unscoped._update_record(
+                  arel_attributes_with_values(attribute_names),
+                  Hash[self.class.primary_key.zip(id_in_database)].merge(
+                      locking_column => previous_lock_value
+                  )
               )
             else
-              affected_rows = relation.where(
-                  self.class.primary_key => id,
-                  lock_col => previous_lock_value,
-              ).update_all(
-                  attributes_for_update(attribute_names).map do |name|
-                      [name, _read_attribute(name)]
-                  end.to_h
+              affected_rows = self.class.unscoped._update_record(
+                  arel_attributes_with_values(attribute_names),
+                  self.class.primary_key => id_in_database,
+                  locking_column         => previous_lock_value
               )
             end
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "update")
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
             end
 
             affected_rows
 
-          # If something went wrong, revert the version.
+              # If something went wrong, revert the locking_column value.
           rescue Exception
-            send(lock_col + '=', previous_lock_value)
+            self[locking_column] = previous_lock_value.to_i
             raise
           end
         end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -41,7 +41,7 @@ module ActiveRecord
                                attribute_ids = attribute_collection['id'] || attribute_collection[:id]
                                if attribute_ids
                                  ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
-                                 eq_predicates = Class.new.extend(CompositePrimaryKeys::Predicates).cpk_id_predicate(association.klass.arel_table, association.klass.primary_key, ids)
+                                 eq_predicates = CompositePrimaryKeys::Predicates.cpk_id_predicate(association.klass.arel_table, association.klass.primary_key, ids)
                                  association.scope.where(eq_predicates).to_a
                                else
                                  []

data/lib/composite_primary_keys/relation/batches.rb

@@ -7,11 +7,17 @@ module CompositePrimaryKeys
           return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
-        if arel.orders.present? || arel.taken.present?
-          act_on_order_or_limit_ignored(error_on_ignore)
+        if arel.orders.present?
+          act_on_ignored_order(error_on_ignore)
         end
 
-        relation = relation.reorder(batch_order).limit(of)
+        batch_limit = of
+        if limit_value
+          remaining   = limit_value
+          batch_limit = remaining if remaining < batch_limit
+        end
+
+        relation = relation.reorder(batch_order).limit(batch_limit)
         relation = apply_limits(relation, start, finish)
         batch_relation = relation
 
@@ -39,9 +45,22 @@ module CompositePrimaryKeys
 
           yield yielded_relation
 
-          break if ids.length < of
+          break if ids.length < batch_limit
+
+          if limit_value
+            remaining -= ids.length
+
+            if remaining == 0
+              # Saves a useless iteration when the limit is a multiple of the
+              # batch size.
+              break
+            elsif remaining < batch_limit
+              relation = relation.limit(remaining)
+            end
+          end
+
           # CPK
-          # batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+          batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
           batch_relation = if composite?
             # CPK
             # Lexicographically select records

data/lib/composite_primary_keys/relation/predicate_builder/association_query_handler.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  class PredicateBuilder
+    class AssociationQueryHandler
+      def call(attribute, value)
+        queries = {}
+
+        table = value.associated_table
+        if value.base_class
+          queries[table.association_foreign_type.to_s] = value.base_class.name
+        end
+
+        # CPK
+        # queries[table.association_foreign_key.to_s] = value.ids
+        # predicate_builder.build_from_hash(queries)
+        if table.association_foreign_key.is_a?(Array)
+          values = case value.value
+                    when Relation
+                      value.ids.map {|record| record.ids}
+                    when Array
+                      value.ids
+                    else
+                      [value.ids]
+                    end
+
+          CompositePrimaryKeys::Predicates.cpk_in_predicate(attribute.relation, table.association_foreign_key, values)
+        else
+          queries[table.association_foreign_key.to_s] = value.ids
+          predicate_builder.build_from_hash(queries)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation.rb

@@ -17,7 +17,7 @@ module ActiveRecord
     end
 
     silence_warnings do
-      def _update_record(values, id, id_was) # :nodoc:
+      def _update_record(values, constraints) # :nodoc:
         substitutes, binds = substitute_values values
 
         scope = @klass.unscoped
@@ -27,15 +27,21 @@ module ActiveRecord
         end
 
         # CPK
+        # relation = scope.where(constraints)
         if self.composite?
-          # Not sure if this is a good idea, but replace nil id_was with the new id
-          id_update = id_was.each_with_index.map do |value, i|
-            value || id[i]
+          if constraints[@klass.primary_key]
+            cpks   = @klass.primary_key.zip(constraints[@klass.primary_key]).to_h
+            others = constraints.except(@klass.primary_key)
+          else
+            cpks   = Hash.new
+            others = Hash.new
+            constraints.each do |field, value|
+              (@klass.primary_key.include?(field) ? cpks : others)[field] = value
+            end
           end
-
-          relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_update))
+          relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, cpks.keys, cpks.values)).where(others)
         else
-          relation = scope.where(@klass.primary_key => (id_was || id))
+          relation = scope.where(constraints)
         end
 
 

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
 module CompositePrimaryKeys
   module VERSION
-    MAJOR = 9
+    MAJOR = 10
     MINOR = 0
-    TINY  = 10
+    TINY  = 5
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/lib/composite_primary_keys.rb

@@ -26,7 +26,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '~>5.0.0.beta3'
+  gem 'activerecord', ['~>5.1.0', '>= 5.1.5']
   require 'active_record'
 end
 
@@ -59,12 +59,12 @@ require 'active_record/nested_attributes'
 
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/abstract_mysql_adapter'
+require 'active_record/connection_adapters/postgresql/database_statements'
 
 require 'active_record/relation/batches'
 require 'active_record/relation/where_clause'
 require 'active_record/relation/calculations'
 require 'active_record/relation/finder_methods'
-require 'active_record/relation/predicate_builder'
 require 'active_record/relation/query_methods'
 
 # CPK files
@@ -98,12 +98,13 @@ require 'composite_primary_keys/nested_attributes'
 
 require 'composite_primary_keys/connection_adapters/abstract_adapter'
 require 'composite_primary_keys/connection_adapters/abstract_mysql_adapter'
+require 'composite_primary_keys/connection_adapters/postgresql/database_statements'
 
 require 'composite_primary_keys/relation/batches'
 require 'composite_primary_keys/relation/where_clause'
 require 'composite_primary_keys/relation/calculations'
 require 'composite_primary_keys/relation/finder_methods'
-require 'composite_primary_keys/relation/predicate_builder'
+require 'composite_primary_keys/relation/predicate_builder/association_query_handler'
 require 'composite_primary_keys/relation/query_methods'
 
 require 'composite_primary_keys/composite_relation'

data/test/test_find.rb

@@ -93,13 +93,19 @@ class TestFind < ActiveSupport::TestCase
     assert_equal(Department.count, num_found)
   end
 
-  def test_expand
+  def test_find_by_one_association
     department = departments(:engineering)
     employees = Employee.where(:department => department)
-    assert_equal(2, employees.count)
+    assert_equal(2, employees.to_a.count)
   end
 
-  def test_expand_with_multiple
+  def test_find_by_all_associations
+    departments = Department.all
+    employees = Employee.where(:department => departments)
+    assert_equal(4, employees.to_a.count)
+  end
+
+  def test_expand_all
     departments = Department.all
     employees = Employee.where(:department => departments)
     assert_equal(4, employees.count)

data/test/test_preload.rb

@@ -91,4 +91,11 @@ class TestPreload < ActiveSupport::TestCase
     assert_equal(1, employees.first.groups_2.size)
     assert_equal(2, employees.second.groups_2.size)
   end
+
+  def test_preload_settings_inversion
+    users = User.preload(:readings).all
+    reading = users.first.readings.first
+
+    assert_equal(true, reading.association(:user).loaded?)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 9.0.10
+  version: 10.0.5
 platform: ruby
 authors:
 - Charlie Savage
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.1.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.7
+        version: 5.1.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 5.1.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.7
+        version: 5.1.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +119,7 @@ files:
 - lib/composite_primary_keys/composite_relation.rb
 - lib/composite_primary_keys/connection_adapters/abstract_adapter.rb
 - lib/composite_primary_keys/connection_adapters/abstract_mysql_adapter.rb
+- lib/composite_primary_keys/connection_adapters/postgresql/database_statements.rb
 - lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb
 - lib/composite_primary_keys/connection_adapters/sqlserver_adapter.rb
 - lib/composite_primary_keys/core.rb
@@ -130,7 +131,7 @@ files:
 - lib/composite_primary_keys/relation/batches.rb
 - lib/composite_primary_keys/relation/calculations.rb
 - lib/composite_primary_keys/relation/finder_methods.rb
-- lib/composite_primary_keys/relation/predicate_builder.rb
+- lib/composite_primary_keys/relation/predicate_builder/association_query_handler.rb
 - lib/composite_primary_keys/relation/query_methods.rb
 - lib/composite_primary_keys/relation/where_clause.rb
 - lib/composite_primary_keys/sanitization.rb

data/lib/composite_primary_keys/relation/predicate_builder.rb

@@ -1,26 +0,0 @@
-module ActiveRecord
-  class PredicateBuilder
-    silence_warnings do
-      def expand(column, value)
-        # Find the foreign key when using queries such as:
-        # Post.where(author: author)
-        #
-        # For polymorphic relationships, find the foreign key and type:
-        # PriceEstimate.where(estimate_of: treasure)
-
-        # CPK
-        if Base === Array(value).first && Array(value).first.composite? && reflection = table.associated_with?(column)
-          columns = reflection.foreign_key
-          values = Array(value).map{|v| columns.map{|c| v.public_send(c) }}
-          cpk_predicate_builder = Class.new.extend(CompositePrimaryKeys::Predicates)
-          predicate = cpk_predicate_builder.cpk_in_predicate(table.send(:arel_table), columns, values)
-          return predicate
-        else
-          # Original code
-          value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
-          build(table.arel_attribute(column), value)
-        end
-      end
-    end
-  end
-end