composite_primary_keys 8.1.0 → 8.1.1

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,69 +1,69 @@
-module ActiveRecord
-  module Associations
-    class HasManyAssociation
-      def delete_count(method, scope)
-        if method == :delete_all
-          scope.delete_all
-        else
-          # CPK
-          # scope.update_all(reflection.foreign_key => nil)
-          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
-            mem[key] = nil
-            mem
-          end
-          scope.update_all(conds)
-        end
-      end
-
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless inverse_updates_counter_cache?
-        else
-          if records == :all || !reflection.klass.primary_key
-            scope = self.scope
-          else
-            # CPK
-            # scope = self.scope.where(reflection.klass.primary_key => records)
-            table = Arel::Table.new(reflection.table_name)
-            and_conditions = records.map do |record|
-              eq_conditions = Array(reflection.association_primary_key).map do |name|
-                table[name].eq(record[name])
-              end
-              Arel::Nodes::And.new(eq_conditions)
-            end
-
-            condition = and_conditions.shift
-            and_conditions.each do |and_condition|
-              condition = condition.or(and_condition)
-            end
-
-            scope = self.scope.where(condition)
-          end
-
-          if method == :delete_all
-            update_counter(-scope.delete_all)
-          else
-            # CPK
-            # update_counter(-scope.update_all(reflection.foreign_key => nil))
-            update_hash = Array(reflection.foreign_key).inject(Hash.new) do |hash, key|
-              hash[key] = nil
-              hash
-            end
-            update_counter(-scope.update_all(update_hash))
-          end
-        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
+module ActiveRecord
+  module Associations
+    class HasManyAssociation
+      def delete_count(method, scope)
+        if method == :delete_all
+          scope.delete_all
+        else
+          # CPK
+          # scope.update_all(reflection.foreign_key => nil)
+          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
+            mem[key] = nil
+            mem
+          end
+          scope.update_all(conds)
+        end
+      end
+
+      def delete_records(records, method)
+        if method == :destroy
+          records.each(&:destroy!)
+          update_counter(-records.length) unless inverse_updates_counter_cache?
+        else
+          if records == :all || !reflection.klass.primary_key
+            scope = self.scope
+          else
+            # CPK
+            # scope = self.scope.where(reflection.klass.primary_key => records)
+            table = Arel::Table.new(reflection.table_name)
+            and_conditions = records.map do |record|
+              eq_conditions = Array(reflection.association_primary_key).map do |name|
+                table[name].eq(record[name])
+              end
+              Arel::Nodes::And.new(eq_conditions)
+            end
+
+            condition = and_conditions.shift
+            and_conditions.each do |and_condition|
+              condition = condition.or(and_condition)
+            end
+
+            scope = self.scope.where(condition)
+          end
+
+          if method == :delete_all
+            update_counter(-scope.delete_all)
+          else
+            # CPK
+            # update_counter(-scope.update_all(reflection.foreign_key => nil))
+            update_hash = Array(reflection.foreign_key).inject(Hash.new) do |hash, key|
+              hash[key] = nil
+              hash
+            end
+            update_counter(-scope.update_all(update_hash))
+          end
+        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/join_dependency.rb

@@ -1,87 +1,87 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class Aliases # :nodoc:
-        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
-
-      def instantiate(result_set, aliases)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |h,parent_klass|
-          h[parent_klass] = Hash.new { |i,parent_id|
-            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
-          }
-        }
-
-        model_cache = Hash.new { |h,klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
-
-        result_set.each { |row_hash|
-          # CPK
-          primary_id = if primary_key.kind_of?(Array)
-                         primary_key.map {|key| row_hash[key]}
-                       else
-                         row_hash[primary_key]
-                       end
-          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
-          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
-        }
-
-        parents.values
-      end
-
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
-        primary_id  = ar_parent.id
-
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          else
-            if ar_parent.association_cache.key?(node.reflection.name)
-              model = ar_parent.association(node.reflection.name).target
-              construct(model, node, row, rs, seen, model_cache, aliases)
-              next
-            end
-          end
-
-          key = aliases.column_alias(node, node.primary_key)
-
-          # CPK
-          if key.is_a?(Array)
-            id = Array(key).map do |column_alias|
-              value = row[column_alias]
-            end
-            # At least the first value in the key has to be set.  Should we require all values to be set?
-            next if id.first.nil?
-          else
-            id = row[key]
-            next if id.nil?
-          end
-
-          model = seen[parent.base_klass][primary_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[parent.base_klass][primary_id][node.base_klass][id] = model
-            construct(model, node, row, rs, seen, model_cache, aliases)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class Aliases # :nodoc:
+        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
+
+      def instantiate(result_set, aliases)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |h,parent_klass|
+          h[parent_klass] = Hash.new { |i,parent_id|
+            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
+          }
+        }
+
+        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases join_root
+
+        result_set.each { |row_hash|
+          # CPK
+          primary_id = if primary_key.kind_of?(Array)
+                         primary_key.map {|key| row_hash[key]}
+                       else
+                         row_hash[primary_key]
+                       end
+          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
+          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+        }
+
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        primary_id  = ar_parent.id
+
+        parent.children.each do |node|
+          if node.reflection.collection?
+            other = ar_parent.association(node.reflection.name)
+            other.loaded!
+          else
+            if ar_parent.association_cache.key?(node.reflection.name)
+              model = ar_parent.association(node.reflection.name).target
+              construct(model, node, row, rs, seen, model_cache, aliases)
+              next
+            end
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+
+          # CPK
+          if key.is_a?(Array)
+            id = Array(key).map do |column_alias|
+              value = row[column_alias]
+            end
+            # At least the first value in the key has to be set.  Should we require all values to be set?
+            next if id.first.nil?
+          else
+            id = row[key]
+            next if id.nil?
+          end
+
+          model = seen[parent.base_klass][primary_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[parent.base_klass][primary_id][node.base_klass][id] = model
+            construct(model, node, row, rs, seen, model_cache, aliases)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,90 +1,90 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class Association
-        def query_scope(ids)
-          # CPK
-          # scope.where(association_key.in(ids))
-
-          if reflection.foreign_key.is_a?(Array)
-            predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
-            scope.where(predicate)
-          else
-            scope.where(association_key.in(ids))
-          end
-        end
-
-        def associated_records_by_owner(preloader)
-          owners_map = owners_by_key
-          # CPK
-          # owner_keys = owners_map.keys.compact
-          owner_keys = if reflection.foreign_key.is_a?(Array)
-            owners.map do |owner|
-              Array(owner_key_name).map do |owner_key|
-                owner[owner_key]
-              end
-            end.compact.uniq
-          else
-            owners_map.keys.compact
-          end
-
-          # Each record may have multiple owners, and vice-versa
-          records_by_owner = owners.each_with_object({}) do |owner,h|
-            h[owner] = []
-          end
-
-          if owner_keys.any?
-            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
-            # Make several smaller queries if necessary or make one query if the adapter supports it
-            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
-
-            records = load_slices sliced
-            records.each do |record, owner_key|
-              owners_map[owner_key].each do |owner|
-                records_by_owner[owner] << record
-              end
-            end
-          end
-
-          records_by_owner
-        end
-
-        def load_slices(slices)
-          @preloaded_records = slices.flat_map { |slice|
-            records_for(slice)
-          }
-
-          @preloaded_records.map { |record|
-            # CPK
-            #[record, record[association_key_name]]
-            owner_key = Array(association_key_name).map do |key_name|
-              record[key_name]
-            end.join(CompositePrimaryKeys::ID_SEP)
-            [record, owner_key]
-          }
-        end
-
-        def owners_by_key
-          @owners_by_key ||= if key_conversion_required?
-                               owners.group_by do |owner|
-                                 # CPK
-                                 # owner[owner_key_name].to_s
-                                 key = Array(owner_key_name).map do |key_name|
-                                   owner[key_name]
-                                 end.join(CompositePrimaryKeys::ID_SEP)
-                               end
-                             else
-                               owners.group_by do |owner|
-                                 # CPK
-                                 # owner[owner_key_name]
-                                 key = Array(owner_key_name).map do |key_name|
-                                   owner[key_name]
-                                 end.join(CompositePrimaryKeys::ID_SEP)
-                               end
-                             end
-                             
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association
+        def query_scope(ids)
+          # CPK
+          # scope.where(association_key.in(ids))
+
+          if reflection.foreign_key.is_a?(Array)
+            predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
+        end
+
+        def associated_records_by_owner(preloader)
+          owners_map = owners_by_key
+          # CPK
+          # owner_keys = owners_map.keys.compact
+          owner_keys = if reflection.foreign_key.is_a?(Array)
+            owners.map do |owner|
+              Array(owner_key_name).map do |owner_key|
+                owner[owner_key]
+              end
+            end.compact.uniq
+          else
+            owners_map.keys.compact
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = owners.each_with_object({}) do |owner,h|
+            h[owner] = []
+          end
+
+          if owner_keys.any?
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+
+            records = load_slices sliced
+            records.each do |record, owner_key|
+              owners_map[owner_key].each do |owner|
+                records_by_owner[owner] << record
+              end
+            end
+          end
+
+          records_by_owner
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
+            # CPK
+            #[record, record[association_key_name]]
+            owner_key = Array(association_key_name).map do |key_name|
+              record[key_name]
+            end.join(CompositePrimaryKeys::ID_SEP)
+            [record, owner_key]
+          }
+        end
+
+        def owners_by_key
+          @owners_by_key ||= if key_conversion_required?
+                               owners.group_by do |owner|
+                                 # CPK
+                                 # owner[owner_key_name].to_s
+                                 key = Array(owner_key_name).map do |key_name|
+                                   owner[key_name]
+                                 end.join(CompositePrimaryKeys::ID_SEP)
+                               end
+                             else
+                               owners.group_by do |owner|
+                                 # CPK
+                                 # owner[owner_key_name]
+                                 key = Array(owner_key_name).map do |key_name|
+                                   owner[key_name]
+                                 end.join(CompositePrimaryKeys::ID_SEP)
+                               end
+                             end
+                             
+        end
+      end
+    end
+  end
+end