composite_primary_keys 13.0.1 → 13.0.2

data/lib/composite_primary_keys/persistence.rb

@@ -1,82 +1,82 @@
-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 = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        um = arel_table.where(
-          constraints.reduce(&:and)
-        ).compile_update(_substitute_values(values), primary_key)
-
-        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 = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        dm = Arel::DeleteManager.new
-        dm.from(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
-
-      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 = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        um = arel_table.where(
+          constraints.reduce(&:and)
+        ).compile_update(_substitute_values(values), primary_key)
+
+        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 = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        dm = Arel::DeleteManager.new
+        dm.from(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
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,104 +1,104 @@
-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) }
-
-        type_cast_calculated_value(result.cast_values.first, operation) 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) }
+
+        type_cast_calculated_value(result.cast_values.first, operation) 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/sanitization.rb

@@ -1,43 +1,43 @@
-module ActiveRecord
-  module Sanitization
-    module ClassMethods
-    #   def expand_hash_conditions_for_aggregates(attrs)
-    #     expanded_attrs = {}
-    #     attrs.each do |attr, value|
-    #       # CPK
-    #       # if aggregation = reflect_on_aggregation(attr.to_sym)
-    #       if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
-    #         value = value.split('/') if value.is_a?(String)
-    #         attr.each_with_index do |key,i|
-    #           expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
-    #         end
-    #       elsif aggregation = reflect_on_aggregation(attr.to_sym)
-    #         mapping = aggregation.mapping
-    #         mapping.each do |field_attr, aggregate_attr|
-    #           if mapping.size == 1 && !value.respond_to?(aggregate_attr)
-    #             expanded_attrs[field_attr] = value
-    #           else
-    #             expanded_attrs[field_attr] = value.send(aggregate_attr)
-    #           end
-    #         end
-    #       else
-    #         expanded_attrs[attr] = value
-    #       end
-    #     end
-    #     expanded_attrs
-    #   end
-    #
-    #   def quoted_id
-    #     # CPK
-    #     # self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
-    #     if self.composite?
-    #       [self.class.primary_keys, ids].transpose.map { |attr_name,id|
-    #         self.class.quote_value(@attributes[attr_name].value_for_database)
-    #       }
-    #     else
-    #       self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
-    #     end
-    #   end
-    end
-  end
+module ActiveRecord
+  module Sanitization
+    module ClassMethods
+    #   def expand_hash_conditions_for_aggregates(attrs)
+    #     expanded_attrs = {}
+    #     attrs.each do |attr, value|
+    #       # CPK
+    #       # if aggregation = reflect_on_aggregation(attr.to_sym)
+    #       if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
+    #         value = value.split('/') if value.is_a?(String)
+    #         attr.each_with_index do |key,i|
+    #           expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
+    #         end
+    #       elsif aggregation = reflect_on_aggregation(attr.to_sym)
+    #         mapping = aggregation.mapping
+    #         mapping.each do |field_attr, aggregate_attr|
+    #           if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+    #             expanded_attrs[field_attr] = value
+    #           else
+    #             expanded_attrs[field_attr] = value.send(aggregate_attr)
+    #           end
+    #         end
+    #       else
+    #         expanded_attrs[attr] = value
+    #       end
+    #     end
+    #     expanded_attrs
+    #   end
+    #
+    #   def quoted_id
+    #     # CPK
+    #     # self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+    #     if self.composite?
+    #       [self.class.primary_keys, ids].transpose.map { |attr_name,id|
+    #         self.class.quote_value(@attributes[attr_name].value_for_database)
+    #       }
+    #     else
+    #       self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+    #     end
+    #   end
+    end
+  end
 end

data/lib/composite_primary_keys/transactions.rb

@@ -1,34 +1,34 @@
-module ActiveRecord
-  module Transactions
-    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-    def restore_transaction_record_state(force_restore_state = false)
-      if restore_state = @_start_transaction_state
-        if force_restore_state || restore_state[:level] <= 1
-          @new_record = restore_state[:new_record]
-          @destroyed  = restore_state[:destroyed]
-          @attributes = restore_state[:attributes].map do |attr|
-            value = @attributes.fetch_value(attr.name)
-            attr = attr.with_value_from_user(value) if attr.value != value
-            attr
-          end
-          @mutations_from_database = nil
-          @mutations_before_last_save = nil
-
-          # CPK
-          if self.composite?
-            values = @primary_key.map {|attribute| @attributes.fetch_value(attribute)}
-            restore_id = restore_state[:id]
-            if values != restore_id
-              @primary_key.each_with_index do |attribute, i|
-                @attributes.write_from_user(attribute, restore_id[i])
-              end
-            end
-          elsif @attributes.fetch_value(@primary_key) != restore_state[:id]
-            @attributes.write_from_user(@primary_key, restore_state[:id])
-          end
-          freeze if restore_state[:frozen?]
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Transactions
+    # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
+    def restore_transaction_record_state(force_restore_state = false)
+      if restore_state = @_start_transaction_state
+        if force_restore_state || restore_state[:level] <= 1
+          @new_record = restore_state[:new_record]
+          @destroyed  = restore_state[:destroyed]
+          @attributes = restore_state[:attributes].map do |attr|
+            value = @attributes.fetch_value(attr.name)
+            attr = attr.with_value_from_user(value) if attr.value != value
+            attr
+          end
+          @mutations_from_database = nil
+          @mutations_before_last_save = nil
+
+          # CPK
+          if self.composite?
+            values = @primary_key.map {|attribute| @attributes.fetch_value(attribute)}
+            restore_id = restore_state[:id]
+            if values != restore_id
+              @primary_key.each_with_index do |attribute, i|
+                @attributes.write_from_user(attribute, restore_id[i])
+              end
+            end
+          elsif @attributes.fetch_value(@primary_key) != restore_state[:id]
+            @attributes.write_from_user(@primary_key, restore_state[:id])
+          end
+          freeze if restore_state[:frozen?]
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,32 +1,32 @@
-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)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
-
-        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
+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)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        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

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