composite_primary_keys 14.0.1 → 14.0.2

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

@@ -1,68 +1,68 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class Association
-
-        class LoaderQuery
-          def load_records_for_keys(keys, &block)
-            # CPK
-            if association_key_name.is_a?(Array)
-              predicate = cpk_in_predicate(scope.klass.arel_table, association_key_name, keys)
-              scope.where(predicate).load(&block)
-            else
-              scope.where(association_key_name => keys).load(&block)
-            end
-          end
-        end
-
-        # TODO: is records_for needed anymore? Rails' implementation has changed significantly
-        def records_for(ids)
-          records = if association_key_name.is_a?(Array)
-                      predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
-                      scope.where(predicate)
-                    else
-                      scope.where(association_key_name => ids)
-                    end
-          records.load do |record|
-            # Processing only the first owner
-            # because the record is modified but not an owner
-            owner = owners_by_key[convert_key(record[association_key_name])].first
-            association = owner.association(reflection.name)
-            association.set_inverse_instance(record)
-          end
-        end
-
-        def owners_by_key
-          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
-            # CPK
-            # key = convert_key(owner[owner_key_name])
-            key = if owner_key_name.is_a?(Array)
-                    Array(owner_key_name).map do |key_name|
-                      convert_key(owner[key_name])
-                    end
-                  else
-                    convert_key(owner[owner_key_name])
-                  end
-            (result[key] ||= []) << owner if key
-          end
-        end
-
-        # TODO: is records_by_owner needed anymore? Rails' implementation has changed significantly
-        def records_by_owner
-          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
-            key = if association_key_name.is_a?(Array)
-                    Array(record[association_key_name]).map do |key|
-                      convert_key(key)
-                    end
-                  else
-                    convert_key(record[association_key_name])
-                  end
-            owners_by_key[key].each do |owner|
-              (result[owner] ||= []) << record
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association
+
+        class LoaderQuery
+          def load_records_for_keys(keys, &block)
+            # CPK
+            if association_key_name.is_a?(Array)
+              predicate = cpk_in_predicate(scope.klass.arel_table, association_key_name, keys)
+              scope.where(predicate).load(&block)
+            else
+              scope.where(association_key_name => keys).load(&block)
+            end
+          end
+        end
+
+        # TODO: is records_for needed anymore? Rails' implementation has changed significantly
+        def records_for(ids)
+          records = if association_key_name.is_a?(Array)
+                      predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
+                      scope.where(predicate)
+                    else
+                      scope.where(association_key_name => ids)
+                    end
+          records.load do |record|
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            owner = owners_by_key[convert_key(record[association_key_name])].first
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            # CPK
+            # key = convert_key(owner[owner_key_name])
+            key = if owner_key_name.is_a?(Array)
+                    Array(owner_key_name).map do |key_name|
+                      convert_key(owner[key_name])
+                    end
+                  else
+                    convert_key(owner[owner_key_name])
+                  end
+            (result[key] ||= []) << owner if key
+          end
+        end
+
+        # TODO: is records_by_owner needed anymore? Rails' implementation has changed significantly
+        def records_by_owner
+          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
+            key = if association_key_name.is_a?(Array)
+                    Array(record[association_key_name]).map do |key|
+                      convert_key(key)
+                    end
+                  else
+                    convert_key(record[association_key_name])
+                  end
+            owners_by_key[key].each do |owner|
+              (result[owner] ||= []) << record
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,71 +1,71 @@
-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
-      else
-        Arel::Nodes::And.new(predicates)
-      end
-    end
-
-    def cpk_or_predicate(predicates, group = true)
-      if predicates.length <= 1
-        predicates.first
-      else
-        split_point = predicates.length / 2
-        predicates_first_half = predicates[0...split_point]
-        predicates_second_half = predicates[split_point..-1]
-
-        or_predicate = ::Arel::Nodes::Or.new(cpk_or_predicate(predicates_first_half, false),
-                                             cpk_or_predicate(predicates_second_half, false))
-
-        if group
-          ::Arel::Nodes::Grouping.new(or_predicate)
-        else
-          or_predicate
-        end
-      end
-    end
-
-    def cpk_id_predicate(table, keys, values)
-      # We zip on values then keys in case values are not provided for each key field
-      eq_predicates = values.zip(keys).map do |value, key|
-        table[key].eq(value)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_join_predicate(table1, key1, table2, key2)
-      key1_fields = Array(key1).map {|key| table1[key]}
-      key2_fields = Array(key2).map {|key| table2[key]}
-
-      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
-        key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
-        key_field1.eq(key_field2)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_in_predicate(table, primary_keys, ids)
-      and_predicates = ids.map do |id|
-        cpk_id_predicate(table, primary_keys, id)
-      end
-      cpk_or_predicate(and_predicates)
-    end
-  end
-end
-
-ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::Preloader::Association::LoaderQuery.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::HasManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Base.send(:extend, CompositePrimaryKeys::Predicates)
-ActiveRecord::Reflection::AbstractReflection.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)
+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
+      else
+        Arel::Nodes::And.new(predicates)
+      end
+    end
+
+    def cpk_or_predicate(predicates, group = true)
+      if predicates.length <= 1
+        predicates.first
+      else
+        split_point = predicates.length / 2
+        predicates_first_half = predicates[0...split_point]
+        predicates_second_half = predicates[split_point..-1]
+
+        or_predicate = ::Arel::Nodes::Or.new(cpk_or_predicate(predicates_first_half, false),
+                                             cpk_or_predicate(predicates_second_half, false))
+
+        if group
+          ::Arel::Nodes::Grouping.new(or_predicate)
+        else
+          or_predicate
+        end
+      end
+    end
+
+    def cpk_id_predicate(table, keys, values)
+      # We zip on values then keys in case values are not provided for each key field
+      eq_predicates = values.zip(keys).map do |value, key|
+        table[key].eq(value)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_join_predicate(table1, key1, table2, key2)
+      key1_fields = Array(key1).map {|key| table1[key]}
+      key2_fields = Array(key2).map {|key| table2[key]}
+
+      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
+        key_field1.eq(key_field2)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_in_predicate(table, primary_keys, ids)
+      and_predicates = ids.map do |id|
+        cpk_id_predicate(table, primary_keys, id)
+      end
+      cpk_or_predicate(and_predicates)
+    end
+  end
+end
+
+ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association::LoaderQuery.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Base.send(:extend, CompositePrimaryKeys::Predicates)
+ActiveRecord::Reflection::AbstractReflection.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/persistence.rb

@@ -1,96 +1,96 @@
-module ActiveRecord
-  module Persistence
-    module ClassMethods
-      def delete(id_or_array)
-        # CPK
-        if self.composite?
-          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
-                          [id_or_array]
-                        else
-                          Array(id_or_array)
-                        end
-
-          # Delete should return the number of deleted records
-          id_or_array.map do |id|
-            # Is the passed in id actually a record?
-            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
-          end.sum
-        else
-          delete_by(primary_key => id_or_array)
-        end
-      end
-
-      def _update_record(values, constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-           constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = constraints.map { |name, value| predicate_builder[name, value] }
-
-        default_constraint = build_default_constraint
-        constraints << default_constraint if default_constraint
-
-        if current_scope = self.global_current_scope
-          constraints << current_scope.where_clause.ast
-        end
-
-        um = Arel::UpdateManager.new(arel_table)
-        um.set(values.transform_keys { |name| arel_table[name] })
-        um.wheres = constraints
-
-        connection.update(um, "#{self} Update")
-      end
-
-      def _delete_record(constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-            constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = constraints.map { |name, value| predicate_builder[name, value] }
-
-        default_constraint = build_default_constraint
-        constraints << default_constraint if default_constraint
-
-        if current_scope = self.global_current_scope
-          constraints << current_scope.where_clause.ast
-        end
-
-        dm = Arel::DeleteManager.new(arel_table)
-        dm.wheres = constraints
-
-        connection.delete(dm, "#{self} Destroy")
-      end
-    end
-
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
-
-      new_id = self.class._insert_record(
-          attributes_with_values(attribute_names)
-      )
-
-      # CPK
-      if self.composite?
-        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
-      else
-        self.id ||= new_id if self.class.primary_key
-      end
-
-      @new_record = false
-      @previously_new_record = true
-
-      yield(self) if block_given?
-
-      id
-    end
-  end
-end
+module ActiveRecord
+  module Persistence
+    module ClassMethods
+      def delete(id_or_array)
+        # CPK
+        if self.composite?
+          id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
+                          [id_or_array]
+                        else
+                          Array(id_or_array)
+                        end
+
+          # Delete should return the number of deleted records
+          id_or_array.map do |id|
+            # Is the passed in id actually a record?
+            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
+          end.sum
+        else
+          delete_by(primary_key => id_or_array)
+        end
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+           constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        um = Arel::UpdateManager.new(arel_table)
+        um.set(values.transform_keys { |name| arel_table[name] })
+        um.wheres = constraints
+
+        connection.update(um, "#{self} Update")
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+            constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = constraints.map { |name, value| predicate_builder[name, value] }
+
+        default_constraint = build_default_constraint
+        constraints << default_constraint if default_constraint
+
+        if current_scope = self.global_current_scope
+          constraints << current_scope.where_clause.ast
+        end
+
+        dm = Arel::DeleteManager.new(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
+      end
+    end
+
+    def _create_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+          attributes_with_values(attribute_names)
+      )
+
+      # CPK
+      if self.composite?
+        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
+      else
+        self.id ||= new_id if self.class.primary_key
+      end
+
+      @new_record = false
+      @previously_new_record = true
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end