composite_primary_keys 10.0.5 → 11.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: f506d34f44d88354550c10d7b79f38c206dfa739c9c903e59c888252db3ae9ed
-  data.tar.gz: 06e5788af10e07e0dbe785338aa35c8cce99df310a7e43d3605b1cefb0eaa0ac
+SHA1:
+  metadata.gz: d06bf922f3eb20b48d379ecac345de0ba325c713
+  data.tar.gz: 6d76da0b87220520f5cd255637c587ca5d1ec16a
 SHA512:
-  metadata.gz: 83ec3b8f8f42e7a5c92f11c60cb86fdb8fd4bdc9e6a58f1f3305ffb5c9b6af9b2abaabcaa43eeaa2e40e19cddab4cad5d7e5501905643e7b4fad0749525ac0b7
-  data.tar.gz: d1a8bad2cdea8ff1eab3ba7d5c456d68f008583b26b6000a930f58d319842aa6b2a24e66d7d509bd531cce4852f062797b96e53c0f929ed8aa0c6a19d40621c2
+  metadata.gz: fafab03151230da90b5891b4f821685869bcd3e745b803ce812e4ee85091153a11c076a3f97ebf56b1f6d0fcc57bf7c45c30a7976be90241a3f3dd8b9e09d688
+  data.tar.gz: dade89e143c24027b39a99166798e467fbf6ca5fe83689b31838756d57ecfd27604277b89b016c3effa9538576e4d3267b72ae1d4c5882454455051e55310856

data/History.rdoc

@@ -1,15 +1,6 @@
-== 10.0.5 (2018-06-24)
-* Fix in_batches (Urmo Rae)
+== 11.0.0.beta1 (2017-12-03)
 
-== 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)
+* ActiveRecord 5.2.beta2 support (Charlie Savage)
 
 == 10.0.2 (2017-12-02)
 
@@ -28,10 +19,6 @@
 * 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)
 
 * Fix Paper Trail compatibility (Sean Linsley)

data/README.rdoc

@@ -20,7 +20,8 @@ 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 10.x is designed to work with ActiveRecord 5.1.x (note this is in progress)
+    Version 11.x is designed to work with ActiveRecord 5.2.x (note this is in progress)
+    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

data/lib/composite_primary_keys.rb

@@ -26,7 +26,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', ['~>5.1.0', '>= 5.1.5']
+  gem 'activerecord', '~> 5.2.0.beta2'
   require 'active_record'
 end
 
@@ -35,6 +35,7 @@ require 'active_record/counter_cache'
 require 'active_record/fixtures'
 require 'active_record/model_schema'
 require 'active_record/persistence'
+require 'active_record/reflection'
 require 'active_record/relation'
 require 'active_record/sanitization'
 require 'active_record/attribute_methods'
@@ -42,12 +43,11 @@ require 'active_record/autosave_association'
 
 require 'active_record/associations/association'
 require 'active_record/associations/association_scope'
+require 'active_record/associations/foreign_association'
 require 'active_record/associations/has_many_association'
 require 'active_record/associations/has_many_through_association'
 require 'active_record/associations/join_dependency'
-require 'active_record/associations/join_dependency/join_association'
 require 'active_record/associations/preloader/association'
-require 'active_record/associations/preloader/belongs_to'
 require 'active_record/associations/singular_association'
 require 'active_record/associations/collection_association'
 
@@ -66,6 +66,7 @@ require 'active_record/relation/where_clause'
 require 'active_record/relation/calculations'
 require 'active_record/relation/finder_methods'
 require 'active_record/relation/query_methods'
+require 'active_record/relation/predicate_builder/association_query_value'
 
 # CPK files
 require 'composite_primary_keys/persistence'
@@ -74,6 +75,7 @@ require 'composite_primary_keys/core'
 require 'composite_primary_keys/composite_arrays'
 require 'composite_primary_keys/composite_predicates'
 require 'composite_primary_keys/fixtures'
+require 'composite_primary_keys/reflection'
 require 'composite_primary_keys/relation'
 require 'composite_primary_keys/sanitization'
 require 'composite_primary_keys/attribute_methods'
@@ -82,12 +84,11 @@ require 'composite_primary_keys/version'
 
 require 'composite_primary_keys/associations/association'
 require 'composite_primary_keys/associations/association_scope'
+require 'composite_primary_keys/associations/foreign_association'
 require 'composite_primary_keys/associations/has_many_association'
 require 'composite_primary_keys/associations/has_many_through_association'
 require 'composite_primary_keys/associations/join_dependency'
-require 'composite_primary_keys/associations/join_dependency/join_association'
 require 'composite_primary_keys/associations/preloader/association'
-require 'composite_primary_keys/associations/preloader/belongs_to'
 require 'composite_primary_keys/associations/collection_association'
 
 require 'composite_primary_keys/attribute_methods/primary_key'
@@ -104,11 +105,10 @@ 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/association_query_handler'
+require 'composite_primary_keys/relation/predicate_builder/association_query_value'
 require 'composite_primary_keys/relation/query_methods'
 
 require 'composite_primary_keys/composite_relation'
 
-require 'composite_primary_keys/arel/in'
 require 'composite_primary_keys/arel/to_sql'
 require 'composite_primary_keys/arel/sqlserver'

data/lib/composite_primary_keys/arel/to_sql.rb

@@ -1,12 +1,18 @@
 module Arel
   module Visitors
     class ToSql
-      def visit_CompositePrimaryKeys_Nodes_In o, collector
-        collector << "("
-        visit(o.left, collector)
-        collector << ")"
-        collector << " IN ("
-        visit(o.right, collector) << ")"
+      def visit_Arel_Nodes_In o, collector
+        if Array === o.right && o.right.empty?
+          collector << '1=0'
+        else
+          # CPK
+          collector << "("
+          collector = visit o.left, collector
+          # CPK
+          collector << ")"
+          collector << " IN ("
+          visit(o.right, collector) << ")"
+        end
       end
 
       def visit_CompositePrimaryKeys_CompositeKeys o, collector

data/lib/composite_primary_keys/associations/association.rb

@@ -1,24 +1,22 @@
 module ActiveRecord
   module Associations
     class Association
-      silence_warnings do
-        def creation_attributes
-          attributes = {}
+      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
+        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
 
-          attributes
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.class.base_class.name
+          end
         end
+
+        attributes
       end
     end
   end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -22,11 +22,13 @@ module ActiveRecord
         binds
       end
 
-      def last_chain_scope(scope, table, reflection, owner)
+      def last_chain_scope(scope, reflection, owner)
         join_keys = reflection.join_keys
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
+        table = reflection.aliased_table
+
         # CPK
         # value = transform_value(owner[foreign_key])
         # scope = apply_scope(scope, table, key, value)
@@ -43,11 +45,14 @@ module ActiveRecord
         scope
       end
 
-      def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+      def next_chain_scope(scope, reflection, next_reflection)
         join_keys = reflection.join_keys
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
+        table = reflection.aliased_table
+        foreign_table = next_reflection.aliased_table
+
         # CPK
         # constraint = table[key].eq(foreign_table[foreign_key])
         constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -24,9 +24,10 @@ module CompositePrimaryKeys
     end
 
     def ids_writer(ids)
-      pk_type = reflection.primary_key_type
+      pk_type = reflection.association_primary_key_type
       ids = Array(ids).reject(&:blank?)
       ids.map! { |i| pk_type.cast(i) }
+
       # CPK
       if reflection.association_primary_key.is_a?(Array)
         predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
@@ -34,11 +35,19 @@ module CompositePrimaryKeys
           reflection.association_primary_key.map{ |k| r.send(k) }
         end.values_at(*ids)
       else
-        records = klass.where(reflection.association_primary_key => ids).index_by do |r|
-          r.send(reflection.association_primary_key)
-        end.values_at(*ids)
+        primary_key = reflection.association_primary_key
+        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
-      replace(records)
     end
   end
 end

data/lib/composite_primary_keys/associations/foreign_association.rb

@@ -0,0 +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

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,21 +1,19 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation
-      include CompositePrimaryKeys::Predicates
-
       def delete_records(records, method)
         if method == :destroy
           records.each(&:destroy!)
           update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
-          return
-        # Zerista
+        # 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
-        update_counter(-delete_count(method, scope))
       end
 
       def delete_count(method, scope)
@@ -31,16 +29,6 @@ module ActiveRecord
           scope.update_all(conds)
         end
       end
-
-      def foreign_key_present?
-        if reflection.klass.primary_key
-          # CPK
-          # owner.attribute_present?(reflection.association_primary_key)
-          Array(reflection.klass.primary_key).all? {|key| owner.attribute_present?(key)}
-        else
-          false
-        end
-      end
     end
   end
 end

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -13,75 +13,73 @@ module ActiveRecord
         cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
       end
 
-      silence_warnings do
-        def delete_records(records, method)
-          ensure_not_nested
+      def delete_records(records, method)
+        ensure_not_nested
 
-          scope = through_association.scope
-          # CPK
-          # scope.where! construct_join_attributes(*records)
-          if source_reflection.klass.composite?
-            scope.where! cpk_join_through_predicate(*records)
-          else
-            scope.where! construct_join_attributes(*records)
-          end
+        scope = through_association.scope
+        # CPK
+        # scope.where! construct_join_attributes(*records)
+        if source_reflection.klass.composite?
+          scope.where! cpk_join_through_predicate(*records)
+        else
+          scope.where! construct_join_attributes(*records)
+        end
 
-          case method
-          when :destroy
-            if scope.klass.primary_key
-              count = scope.destroy_all.length
-            else
-              scope.to_a.each do |record|
-                record.run_callbacks :destroy
-              end
+        case method
+        when :destroy
+          if scope.klass.primary_key
+            count = scope.destroy_all.length
+          else
+            scope.to_a.each do |record|
+              record.run_callbacks :destroy
+            end
 
-              arel = scope.arel
+            arel = scope.arel
 
-              stmt = Arel::DeleteManager.new arel.engine
-              stmt.from scope.klass.arel_table
-              stmt.wheres = arel.constraints
+            stmt = Arel::DeleteManager.new arel.engine
+            stmt.from scope.klass.arel_table
+            stmt.wheres = arel.constraints
 
-              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
-            end
-          when :nullify
-            count = scope.update_all(source_reflection.foreign_key => nil)
-          else
-            count = scope.delete_all
+            count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
           end
+        when :nullify
+          count = scope.update_all(source_reflection.foreign_key => nil)
+        else
+          count = scope.delete_all
+        end
 
-          delete_through_records(records)
-
-          if source_reflection.options[:counter_cache] && method != :destroy
-            counter = source_reflection.counter_cache_column
-            klass.decrement_counter counter, records.map(&:id)
-          end
+        delete_through_records(records)
 
-          if through_reflection.collection? && update_through_counter?(method)
-            update_counter(-count, through_reflection)
-          end
+        if source_reflection.options[:counter_cache] && method != :destroy
+          counter = source_reflection.counter_cache_column
+          klass.decrement_counter counter, records.map(&:id)
+        end
 
-          update_counter(-count)
+        if through_reflection.collection? && update_through_counter?(method)
+          update_counter(-count, through_reflection)
         end
 
-        def through_records_for(record)
-          # CPK
-          # attributes = construct_join_attributes(record)
-          # candidates = Array.wrap(through_association.target)
-          # candidates.find_all do |c|
-          #   attributes.all? do |key, value|
-          #     c.public_send(key) == value
-          #   end
-          # end
-          if record.composite?
-            candidates = Array.wrap(through_association.target)
-            candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
-          else
-            attributes = construct_join_attributes(record)
-            candidates = Array.wrap(through_association.target)
-            candidates.find_all do |c|
-              attributes.all? do |key, value|
-                c.public_send(key) == value
-              end
+        update_counter(-count)
+      end
+
+      def through_records_for(record)
+        # CPK
+        # attributes = construct_join_attributes(record)
+        # candidates = Array.wrap(through_association.target)
+        # candidates.find_all do |c|
+        #   attributes.all? do |key, value|
+        #     c.public_send(key) == value
+        #   end
+        # end
+        if record.composite?
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
+        else
+          attributes = construct_join_attributes(record)
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all do |c|
+            attributes.all? do |key, value|
+              c.public_send(key) == value
             end
           end
         end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -2,100 +2,98 @@ module ActiveRecord
   module Associations
     class JoinDependency
       class Aliases # :nodoc:
-        silence_warnings do
-          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]
+        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
 
-      silence_warnings do
-        def instantiate(result_set, &block)
-          primary_key = aliases.column_alias(join_root, join_root.primary_key)
+      def instantiate(result_set, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
-          seen = Hash.new { |i, object_id|
-            i[object_id] = Hash.new { |j, child_class|
-              j[child_class] = {}
-            }
+        seen = Hash.new { |i, object_id|
+          i[object_id] = Hash.new { |j, child_class|
+            j[child_class] = {}
           }
+        }
 
-          model_cache = Hash.new { |h,klass| h[klass] = {} }
-          parents = model_cache[join_root]
-          column_aliases = aliases.column_aliases join_root
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases join_root
 
-          message_bus = ActiveSupport::Notifications.instrumenter
+        message_bus = ActiveSupport::Notifications.instrumenter
 
-          payload = {
+        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 = 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, &block)
-              construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
-            }
-          end
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            # CPK
+            # parent_key = primary_key ? row_hash[primary_key] : row_hash
+            # CPK
+            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
 
-          parents.values
+            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
 
-        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-          return if ar_parent.nil?
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        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, rs, seen, model_cache, aliases)
-              next
-            end
+        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, rs, seen, model_cache, aliases)
+            next
+          end
 
-            key = aliases.column_alias(node, node.primary_key)
+          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]
+          # 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? # duplicating this so it is clear what remained unchanged from the original
-              nil_association = ar_parent.association(node.reflection.name)
-              nil_association.loaded!
-              next
-            end
+          if id.nil? # duplicating this so it is clear what remained unchanged from the original
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
 
-            model = seen[ar_parent.object_id][node.base_klass][id]
+          model = seen[ar_parent.object_id][node.base_klass][id]
 
-            if model
-              construct(model, node, row, rs, seen, model_cache, aliases)
-            else
-              model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-              seen[ar_parent.object_id][node.base_klass][id] = model
-              construct(model, node, row, rs, seen, model_cache, aliases)
-            end
+          if model
+            construct(model, node, row, rs, seen, model_cache, aliases)
+          else
+            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
+            seen[ar_parent.object_id][node.base_klass][id] = model
+            construct(model, node, row, rs, seen, model_cache, aliases)
           end
         end
       end