composite_primary_keys 14.0.7 → 14.0.8

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

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,110 +1,110 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          # Note: Test don't seem to run this code?
-          column_name.map do |column|
-            @klass.arel_table[column]
-          end
-        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_table[column_name]
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
-        end
-      end
-
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        column_alias = column_name
-
-        # CPK
-        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
-        #   # Shortcut when limit is zero.
-        #   return 0 if limit_value == 0
-        #
-        #   query_builder = build_count_subquery(spawn, column_name, distinct)
-        if operation == "count"
-          relation = unscope(:order)
-          query_builder = build_count_subquery(spawn, column_name, distinct)
-        else
-          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
-          relation = unscope(:order).distinct!(false)
-
-          column = aggregate_column(column_name)
-          select_value = operation_over_aggregate_column(column, operation, distinct)
-          select_value.distinct = true if operation == "sum" && distinct
-
-          relation.select_values = [select_value]
-
-          query_builder = relation.arel
-        end
-
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
-
-        if operation != "count"
-          type = column.try(:type_caster) ||
-            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
-          type = type.subtype if ::ActiveRecord::Enum::EnumType === type
-        end
-
-        type_cast_calculated_value(result.cast_values.first, operation, type) do |value|
-          type = column.try(:type_caster) ||
-            # CPK
-            # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
-            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
-          type.deserialize(value)
-        end
-      end
-
-      def build_count_subquery(relation, column_name, distinct)
-        if column_name == :all
-          column_alias = Arel.star
-          # CPK
-          # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
-          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
-        elsif column_name.is_a?(Array)
-          column_alias = Arel.star
-          relation.select_values = column_name.map do |column|
-            Arel::Attribute.new(@klass.unscoped.table, column)
-          end
-        else
-          column_alias = Arel.sql("count_column")
-          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
-        end
-
-        subquery_alias = Arel.sql("subquery_for_count")
-        select_value = operation_over_aggregate_column(column_alias, "count", false)
-
-        relation.build_subquery(subquery_alias, select_value)
-      end
-
-      def calculate(operation, column_name)
-        if has_include?(column_name)
-          relation = apply_join_dependency
-
-          if operation.to_s.downcase == "count"
-            unless distinct_value || distinct_select?(column_name || select_for_count)
-              relation.distinct!
-              # CPK
-              # relation.select_values = [ klass.primary_key || table[Arel.star] ]
-              if klass.primary_key.present? && klass.primary_key.is_a?(Array)
-                relation.select_values = klass.primary_key.map do |k|
-                  "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
-                end
-              else
-                relation.select_values = [ klass.primary_key || table[Arel.star] ]
-              end
-            end
-            # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
-            relation.order_values = [] if group_values.empty?
-          end
-
-          relation.calculate(operation, column_name)
-        else
-          perform_calculation(operation, column_name)
-        end
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      def aggregate_column(column_name)
+        # CPK
+        if column_name.kind_of?(Array)
+          # Note: Test don't seem to run this code?
+          column_name.map do |column|
+            @klass.arel_table[column]
+          end
+        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
+          @klass.arel_table[column_name]
+        else
+          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        end
+      end
+
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        column_alias = column_name
+
+        # CPK
+        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+        #   # Shortcut when limit is zero.
+        #   return 0 if limit_value == 0
+        #
+        #   query_builder = build_count_subquery(spawn, column_name, distinct)
+        if operation == "count"
+          relation = unscope(:order)
+          query_builder = build_count_subquery(spawn, column_name, distinct)
+        else
+          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
+          relation = unscope(:order).distinct!(false)
+
+          column = aggregate_column(column_name)
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.distinct = true if operation == "sum" && distinct
+
+          relation.select_values = [select_value]
+
+          query_builder = relation.arel
+        end
+
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
+
+        if operation != "count"
+          type = column.try(:type_caster) ||
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type = type.subtype if ::ActiveRecord::Enum::EnumType === type
+        end
+
+        type_cast_calculated_value(result.cast_values.first, operation, type) do |value|
+          type = column.try(:type_caster) ||
+            # CPK
+            # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
+          type.deserialize(value)
+        end
+      end
+
+      def build_count_subquery(relation, column_name, distinct)
+        if column_name == :all
+          column_alias = Arel.star
+          # CPK
+          # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
+          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
+        elsif column_name.is_a?(Array)
+          column_alias = Arel.star
+          relation.select_values = column_name.map do |column|
+            Arel::Attribute.new(@klass.unscoped.table, column)
+          end
+        else
+          column_alias = Arel.sql("count_column")
+          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+        end
+
+        subquery_alias = Arel.sql("subquery_for_count")
+        select_value = operation_over_aggregate_column(column_alias, "count", false)
+
+        relation.build_subquery(subquery_alias, select_value)
+      end
+
+      def calculate(operation, column_name)
+        if has_include?(column_name)
+          relation = apply_join_dependency
+
+          if operation.to_s.downcase == "count"
+            unless distinct_value || distinct_select?(column_name || select_for_count)
+              relation.distinct!
+              # CPK
+              # relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              if klass.primary_key.present? && klass.primary_key.is_a?(Array)
+                relation.select_values = klass.primary_key.map do |k|
+                  "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
+                end
+              else
+                relation.select_values = [ klass.primary_key || table[Arel.star] ]
+              end
+            end
+            # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
+            relation.order_values = [] if group_values.empty?
+          end
+
+          relation.calculate(operation, column_name)
+        else
+          perform_calculation(operation, column_name)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,40 +1,40 @@
-module ActiveRecord
-  module Validations
-    class UniquenessValidator
-      def validate_each(record, attribute, value)
-        finder_class = find_finder_class_for(record)
-        value = map_enum_attribute(finder_class, attribute, value)
-
-        relation = build_relation(finder_class, attribute, value)
-        if record.persisted?
-          # CPK
-          if finder_class.primary_key.is_a?(Array)
-            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
-            relation = relation.where.not(predicate)
-          elsif finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
-          else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
-          end
-        end
-        relation = scope_relation(record, relation)
-        if options[:conditions]
-          conditions = options[:conditions]
-
-          relation = if conditions.arity.zero?
-            relation.instance_exec(&conditions)
-          else
-            relation.instance_exec(record, &conditions)
-          end
-        end
-
-        if relation.exists?
-          error_options = options.except(:case_sensitive, :scope, :conditions)
-          error_options[:value] = value
-
-          record.errors.add(attribute, :taken, **error_options)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Validations
+    class UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        relation = build_relation(finder_class, attribute, value)
+        if record.persisted?
+          # CPK
+          if finder_class.primary_key.is_a?(Array)
+            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
+            relation = relation.where.not(predicate)
+          elsif finder_class.primary_key
+            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+          else
+            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+          end
+        end
+        relation = scope_relation(record, relation)
+        if options[:conditions]
+          conditions = options[:conditions]
+
+          relation = if conditions.arity.zero?
+            relation.instance_exec(&conditions)
+          else
+            relation.instance_exec(record, &conditions)
+          end
+        end
+
+        if relation.exists?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+
+          record.errors.add(attribute, :taken, **error_options)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 14
     MINOR = 0
-    TINY  = 7
+    TINY  = 8
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/fixtures/department.rb

@@ -1,20 +1,20 @@
-class Department < ActiveRecord::Base
-  self.primary_keys = :id, :location_id
-
-  has_many :employees,
-           # We intentionally redefine primary key for test purposes. #455
-           :primary_key =>  [:id, :location_id],
-           :foreign_key => [:department_id, :location_id]
-
-  has_many :comments, :through => :employees
-
-  has_one :head, :class_name => 'Employee',  :autosave => true, :dependent => :delete,
-                 # We intentionally redefine primary key for test purposes. #455
-                 :primary_key =>  [:id, :location_id],
-                 :foreign_key => [:department_id, :location_id]
-
-  has_one :head_without_autosave, :class_name => 'Employee',
-          # We intentionally redefine primary key for test purposes. #455
-          :primary_key =>  [:id, :location_id],
-          :foreign_key => [:department_id, :location_id]
-end
+class Department < ActiveRecord::Base
+  self.primary_keys = :id, :location_id
+
+  has_many :employees,
+           # We intentionally redefine primary key for test purposes. #455
+           :primary_key =>  [:id, :location_id],
+           :foreign_key => [:department_id, :location_id]
+
+  has_many :comments, :through => :employees
+
+  has_one :head, :class_name => 'Employee',  :autosave => true, :dependent => :delete,
+                 # We intentionally redefine primary key for test purposes. #455
+                 :primary_key =>  [:id, :location_id],
+                 :foreign_key => [:department_id, :location_id]
+
+  has_one :head_without_autosave, :class_name => 'Employee',
+          # We intentionally redefine primary key for test purposes. #455
+          :primary_key =>  [:id, :location_id],
+          :foreign_key => [:department_id, :location_id]
+end

data/test/fixtures/room_assignment.rb

@@ -1,18 +1,18 @@
-class RoomAssignment < ActiveRecord::Base
-  self.primary_keys = :student_id, :dorm_id, :room_id
-  belongs_to :student
-  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
-  validates :student_id, uniqueness: {
-    conditions: ->(record) {
-      where(student_id: record.student_id) # enough just to exercise this code path
-    }
-  }
-
-  before_destroy do |record|
-    puts record
-  end
-
-  after_destroy do |record|
-    puts record
-  end
-end
+class RoomAssignment < ActiveRecord::Base
+  self.primary_keys = :student_id, :dorm_id, :room_id
+  belongs_to :student
+  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
+  validates :student_id, uniqueness: {
+    conditions: ->(record) {
+      where(student_id: record.student_id) # enough just to exercise this code path
+    }
+  }
+
+  before_destroy do |record|
+    puts record
+  end
+
+  after_destroy do |record|
+    puts record
+  end
+end