composite_primary_keys 14.0.9 → 14.0.10

data/lib/composite_primary_keys/autosave_association.rb

@@ -1,60 +1,60 @@
-module ActiveRecord
-  module AutosaveAssociation
-    def save_has_one_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.load_target
-
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          record.destroy
-        elsif autosave != false
-          # CPK
-          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
-
-          if (autosave && record.changed_for_autosave?) || new_record? || _record_changed?(reflection, record, key)
-            unless reflection.through_reflection
-              record[reflection.foreign_key] = key
-              if inverse_reflection = reflection.inverse_of
-                record.association(inverse_reflection.name).loaded!
-              end
-            end
-
-            saved = record.save(validate: !autosave)
-            raise ActiveRecord::Rollback if !saved && autosave
-            saved
-          end
-        end
-      end
-    end
-
-    def save_belongs_to_association(reflection)
-      association = association_instance_get(reflection.name)
-      return unless association && association.loaded? && !association.stale_target?
-
-      record = association.load_target
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          self[reflection.foreign_key] = nil
-          record.destroy
-        elsif autosave != false
-          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
-
-          if association.updated?
-            # CPK
-            # association_id = record.send(reflection.options[:primary_key] || :id)
-            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
-            self[reflection.foreign_key] = association_id
-            association.loaded!
-          end
-
-          saved if autosave
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AutosaveAssociation
+    def save_has_one_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          # CPK
+          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
+
+          if (autosave && record.changed_for_autosave?) || new_record? || _record_changed?(reflection, record, key)
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+              if inverse_reflection = reflection.inverse_of
+                record.association(inverse_reflection.name).loaded!
+              end
+            end
+
+            saved = record.save(validate: !autosave)
+            raise ActiveRecord::Rollback if !saved && autosave
+            saved
+          end
+        end
+      end
+    end
+
+    def save_belongs_to_association(reflection)
+      association = association_instance_get(reflection.name)
+      return unless association && association.loaded? && !association.stale_target?
+
+      record = association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
+          record.destroy
+        elsif autosave != false
+          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+
+          if association.updated?
+            # CPK
+            # association_id = record.send(reflection.options[:primary_key] || :id)
+            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
+            self[reflection.foreign_key] = association_id
+            association.loaded!
+          end
+
+          saved if autosave
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,88 +1,88 @@
-module CompositePrimaryKeys
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-  ESCAPE_CHAR = '^'
-
-  module ArrayExtension
-    def to_composite_keys
-      CompositeKeys.new(self)
-    end
-  end
-
-  # Convert mixed representation of CPKs (by strings or arrays) to normalized
-  # representation (just by arrays).
-  #
-  # `ids` is Array that may contain:
-  # 1. A CPK represented by an array or a string.
-  # 2. An array of CPKs represented by arrays or strings.
-  #
-  # There is an issue. Let `ids` contain an array with serveral strings. We can't distinguish case 1
-  # from case 2 there in general. E.g. the item can be an array containing appropriate number of strings,
-  # and each string can contain appropriate number of commas. We consider case 2 to win there.
-  def self.normalize(ids, cpk_size)
-    ids.map do |id|
-      if Utils.cpk_as_array?(id, cpk_size) && id.any? { |item| !Utils.cpk_as_string?(item, cpk_size) }
-        # CPK as an array - case 1
-        id
-      elsif id.is_a?(Array)
-        # An array of CPKs - case 2
-        normalize(id, cpk_size)
-      elsif id.is_a?(String)
-        # CPK as a string - case 1
-        CompositeKeys.parse(id)
-      else
-        id
-      end
-    end
-  end
-
-  class CompositeKeys < Array
-
-    def self.parse(value)
-      case value
-      when Array
-        value.to_composite_keys
-      when String
-        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
-      else
-        raise(ArgumentError, "Unsupported type: #{value}")
-      end
-    end
-
-    def to_s
-      # Doing this makes it easier to parse Base#[](attr_name)
-      map { |key| Utils.escape_string_key(key.to_s) }.join(ID_SEP)
-    end
-
-    alias_method :to_param, :to_s
-  end
-
-  module Utils
-    class << self
-      def escape_string_key(key)
-        key.gsub(Regexp.union(ESCAPE_CHAR, ID_SEP)) do |unsafe|
-          "#{ESCAPE_CHAR}#{unsafe.ord.to_s(16).upcase}"
-        end
-      end
-
-      def unescape_string_key(key)
-        key.gsub(/#{Regexp.escape(ESCAPE_CHAR)}[0-9a-fA-F]{2}/) do |escaped|
-          char = escaped.slice(1, 2).hex.chr
-          (char == ESCAPE_CHAR || char == ID_SEP) ? char : escaped
-        end
-      end
-
-      def cpk_as_array?(value, pk_size)
-        # We don't permit Array to be an element of CPK.
-        value.is_a?(Array) && value.size == pk_size && value.none? { |item| item.is_a?(Array) }
-      end
-
-      def cpk_as_string?(value, pk_size)
-        value.is_a?(String) && value.count(ID_SEP) == pk_size - 1
-      end
-    end
-  end
-  private_constant :Utils
-end
-
-Array.send(:include, CompositePrimaryKeys::ArrayExtension)
+module CompositePrimaryKeys
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+  ESCAPE_CHAR = '^'
+
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    end
+  end
+
+  # Convert mixed representation of CPKs (by strings or arrays) to normalized
+  # representation (just by arrays).
+  #
+  # `ids` is Array that may contain:
+  # 1. A CPK represented by an array or a string.
+  # 2. An array of CPKs represented by arrays or strings.
+  #
+  # There is an issue. Let `ids` contain an array with serveral strings. We can't distinguish case 1
+  # from case 2 there in general. E.g. the item can be an array containing appropriate number of strings,
+  # and each string can contain appropriate number of commas. We consider case 2 to win there.
+  def self.normalize(ids, cpk_size)
+    ids.map do |id|
+      if Utils.cpk_as_array?(id, cpk_size) && id.any? { |item| !Utils.cpk_as_string?(item, cpk_size) }
+        # CPK as an array - case 1
+        id
+      elsif id.is_a?(Array)
+        # An array of CPKs - case 2
+        normalize(id, cpk_size)
+      elsif id.is_a?(String)
+        # CPK as a string - case 1
+        CompositeKeys.parse(id)
+      else
+        id
+      end
+    end
+  end
+
+  class CompositeKeys < Array
+
+    def self.parse(value)
+      case value
+      when Array
+        value.to_composite_keys
+      when String
+        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
+      else
+        raise(ArgumentError, "Unsupported type: #{value}")
+      end
+    end
+
+    def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
+      map { |key| Utils.escape_string_key(key.to_s) }.join(ID_SEP)
+    end
+
+    alias_method :to_param, :to_s
+  end
+
+  module Utils
+    class << self
+      def escape_string_key(key)
+        key.gsub(Regexp.union(ESCAPE_CHAR, ID_SEP)) do |unsafe|
+          "#{ESCAPE_CHAR}#{unsafe.ord.to_s(16).upcase}"
+        end
+      end
+
+      def unescape_string_key(key)
+        key.gsub(/#{Regexp.escape(ESCAPE_CHAR)}[0-9a-fA-F]{2}/) do |escaped|
+          char = escaped.slice(1, 2).hex.chr
+          (char == ESCAPE_CHAR || char == ID_SEP) ? char : escaped
+        end
+      end
+
+      def cpk_as_array?(value, pk_size)
+        # We don't permit Array to be an element of CPK.
+        value.is_a?(Array) && value.size == pk_size && value.none? { |item| item.is_a?(Array) }
+      end
+
+      def cpk_as_string?(value, pk_size)
+        value.is_a?(String) && value.count(ID_SEP) == pk_size - 1
+      end
+    end
+  end
+  private_constant :Utils
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,121 +1,121 @@
-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)
-      if primary_keys.length == 2
-        cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
-      else
-        cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
-      end
-    end
-
-    def cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
-      and_predicates = ids.map do |id|
-        cpk_id_predicate(table, primary_keys, id)
-      end
-
-      cpk_or_predicate(and_predicates)
-    end
-
-    def cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
-      keys_by_first_column_name = Hash.new { |hash, key| hash[key] = [] }
-      keys_by_second_column_name = Hash.new { |hash, key| hash[key] = [] }
-
-      ids.map.each do |first_key_part, second_key_part|
-        keys_by_first_column_name[first_key_part] << second_key_part
-        keys_by_second_column_name[second_key_part] << first_key_part
-      end
-
-      low_cardinality_column_name, high_cardinality_column_name, groups = \
-        if keys_by_first_column_name.size <= keys_by_second_column_name.size
-          [primary_keys.first, primary_keys.second, keys_by_first_column_name]
-        else
-          [primary_keys.second, primary_keys.first, keys_by_second_column_name]
-        end
-
-      and_predicates = groups.map do |low_cardinality_value, high_cardinality_values|
-        non_nil_high_cardinality_values = high_cardinality_values.compact
-        in_clause = table[high_cardinality_column_name].in(non_nil_high_cardinality_values)
-        inclusion_clauses = if non_nil_high_cardinality_values.size != high_cardinality_values.size
-                              Arel::Nodes::Grouping.new(
-                                Arel::Nodes::Or.new(
-                                  in_clause,
-                                  table[high_cardinality_column_name].eq(nil)
-                                )
-                              )
-                            else
-                              in_clause
-                            end
-
-        Arel::Nodes::And.new(
-          [
-            table[low_cardinality_column_name].eq(low_cardinality_value),
-            inclusion_clauses
-          ]
-        )
-      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)
+      if primary_keys.length == 2
+        cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
+      else
+        cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
+      end
+    end
+
+    def cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
+      and_predicates = ids.map do |id|
+        cpk_id_predicate(table, primary_keys, id)
+      end
+
+      cpk_or_predicate(and_predicates)
+    end
+
+    def cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
+      keys_by_first_column_name = Hash.new { |hash, key| hash[key] = [] }
+      keys_by_second_column_name = Hash.new { |hash, key| hash[key] = [] }
+
+      ids.map.each do |first_key_part, second_key_part|
+        keys_by_first_column_name[first_key_part] << second_key_part
+        keys_by_second_column_name[second_key_part] << first_key_part
+      end
+
+      low_cardinality_column_name, high_cardinality_column_name, groups = \
+        if keys_by_first_column_name.size <= keys_by_second_column_name.size
+          [primary_keys.first, primary_keys.second, keys_by_first_column_name]
+        else
+          [primary_keys.second, primary_keys.first, keys_by_second_column_name]
+        end
+
+      and_predicates = groups.map do |low_cardinality_value, high_cardinality_values|
+        non_nil_high_cardinality_values = high_cardinality_values.compact
+        in_clause = table[high_cardinality_column_name].in(non_nil_high_cardinality_values)
+        inclusion_clauses = if non_nil_high_cardinality_values.size != high_cardinality_values.size
+                              Arel::Nodes::Grouping.new(
+                                Arel::Nodes::Or.new(
+                                  in_clause,
+                                  table[high_cardinality_column_name].eq(nil)
+                                )
+                              )
+                            else
+                              in_clause
+                            end
+
+        Arel::Nodes::And.new(
+          [
+            table[low_cardinality_column_name].eq(low_cardinality_value),
+            inclusion_clauses
+          ]
+        )
+      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/connection_adapters/abstract/database_statements.rb

@@ -1,36 +1,36 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module DatabaseStatements
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = to_sql_and_binds(arel, binds)
-        value = exec_insert(sql, name, binds, pk, sequence_name)
-
-        return id_value if id_value
-        if pk.is_a?(Array) && value.respond_to?(:empty?) && !value.empty?
-          # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
-          # auto incremented field
-          pk.map {|key| value.first[key]}
-        elsif pk.is_a?(Array)
-          # This is CPK, but we don't know what autoincremented fields were updated.
-          result = Array.new(pk.size)
-
-          # Is there an autoincrementing field?
-          auto_key = pk.find do |key|
-            attribute = arel.ast.relation[key]
-            column = column_for_attribute(attribute)
-            if column.respond_to?(:auto_increment?)
-              column.auto_increment?
-            end
-          end
-
-          if auto_key
-            result[pk.index(auto_key)] = last_inserted_id(value)
-          end
-          result
-        else
-          last_inserted_id(value)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql, binds = to_sql_and_binds(arel, binds)
+        value = exec_insert(sql, name, binds, pk, sequence_name)
+
+        return id_value if id_value
+        if pk.is_a?(Array) && value.respond_to?(:empty?) && !value.empty?
+          # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
+          # auto incremented field
+          pk.map {|key| value.first[key]}
+        elsif pk.is_a?(Array)
+          # This is CPK, but we don't know what autoincremented fields were updated.
+          result = Array.new(pk.size)
+
+          # Is there an autoincrementing field?
+          auto_key = pk.find do |key|
+            attribute = arel.ast.relation[key]
+            column = column_for_attribute(attribute)
+            if column.respond_to?(:auto_increment?)
+              column.auto_increment?
+            end
+          end
+
+          if auto_key
+            result[pk.index(auto_key)] = last_inserted_id(value)
+          end
+          result
+        else
+          last_inserted_id(value)
+        end
+      end
+    end
+  end
+end