composite_primary_keys 13.0.1 → 13.0.2

data/lib/composite_primary_keys/associations/foreign_association.rb

@@ -1,15 +1,15 @@
-# frozen_string_literal: true
-
-module ActiveRecord::Associations
-  module ForeignAssociation # :nodoc:
-    def foreign_key_present?
-      if reflection.klass.primary_key
-        # CPK
-        # owner.attribute_present?(reflection.active_record_primary_key)
-        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
-      else
-        false
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ActiveRecord::Associations
+  module ForeignAssociation # :nodoc:
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        # CPK
+        # owner.attribute_present?(reflection.active_record_primary_key)
+        Array(reflection.active_record_primary_key).all? {|key| owner.attribute_present?(key)}
+      else
+        false
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,35 +1,35 @@
-module ActiveRecord
-  module Associations
-    class HasManyAssociation
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
-        # CPK
-        elsif self.reflection.klass.composite?
-          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
-          scope = self.scope.where(predicate)
-          update_counter(-delete_count(method, scope))
-        else
-          scope = self.scope.where(reflection.klass.primary_key => records)
-          update_counter(-delete_count(method, scope))
-        end
-      end
-
-      def delete_count(method, scope)
-        if method == :delete_all
-          scope.delete_all
-        else
-          # CPK
-          # scope.update_all(nullified_owner_attributes)
-          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
-            mem[key] = nil
-            mem
-          end
-          conds[reflection.type] = nil if reflection.type.present?
-          scope.update_all(conds)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class HasManyAssociation
+      def delete_records(records, method)
+        if method == :destroy
+          records.each(&:destroy!)
+          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
+        # CPK
+        elsif self.reflection.klass.composite?
+          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
+          scope = self.scope.where(predicate)
+          update_counter(-delete_count(method, scope))
+        else
+          scope = self.scope.where(reflection.klass.primary_key => records)
+          update_counter(-delete_count(method, scope))
+        end
+      end
+
+      def delete_count(method, scope)
+        if method == :delete_all
+          scope.delete_all
+        else
+          # CPK
+          # scope.update_all(nullified_owner_attributes)
+          conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
+            mem[key] = nil
+            mem
+          end
+          conds[reflection.type] = nil if reflection.type.present?
+          scope.update_all(conds)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/{join_dependency.rb → join_association.rb}

@@ -11,7 +11,7 @@ module ActiveRecord
             else
               right = join.right
               # CPK
-              if right.expr.children.empty?
+              if right.expr.is_a?(Arel::Nodes::And) && right.expr.children.empty?
                 right.expr = Arel::Nodes::And.new(constraints)
               else
                 right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)

data/lib/composite_primary_keys/associations/through_association.rb

@@ -1,25 +1,25 @@
-module ActiveRecord
-  module Associations
-    module ThroughAssociation
-      alias :original_construct_join_attributes :construct_join_attributes
-
-      def construct_join_attributes(*records)
-        # CPK
-        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
-        if is_composite
-          ensure_mutable
-
-          ids = records.map do |record|
-            source_reflection.association_primary_key(reflection.klass).map do |key|
-              record.send(key)
-            end
-          end
-
-          cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
-        else
-          original_construct_join_attributes(*records)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    module ThroughAssociation
+      alias :original_construct_join_attributes :construct_join_attributes
+
+      def construct_join_attributes(*records)
+        # CPK
+        is_composite = self.source_reflection.polymorphic? ? source_reflection.active_record.composite? : source_reflection.klass.composite?
+        if is_composite
+          ensure_mutable
+
+          ids = records.map do |record|
+            source_reflection.association_primary_key(reflection.klass).map do |key|
+              record.send(key)
+            end
+          end
+
+          cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
+        else
+          original_construct_join_attributes(*records)
+        end
+      end
+    end
+  end
+end

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,86 +1,86 @@
-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
-  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
+  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_relation.rb

@@ -1,29 +1,29 @@
-module CompositePrimaryKeys
-  module CompositeRelation
-    include CompositePrimaryKeys::ActiveRecord::Batches
-    include CompositePrimaryKeys::ActiveRecord::Calculations
-    include CompositePrimaryKeys::ActiveRecord::FinderMethods
-    include CompositePrimaryKeys::ActiveRecord::QueryMethods
-
-    def destroy(id_or_array)
-      # Without CPK:
-      #if id.is_a?(Array)
-      #  id.map { |one_id| destroy(one_id) }
-      #else
-      #  find(id).destroy
-      #end
-
-      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
-        [id_or_array]
-      else
-        Array(id_or_array)
-      end
-
-      id_or_array.each do |id|
-        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
-          record.destroy
-        end
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module CompositeRelation
+    include CompositePrimaryKeys::ActiveRecord::Batches
+    include CompositePrimaryKeys::ActiveRecord::Calculations
+    include CompositePrimaryKeys::ActiveRecord::FinderMethods
+    include CompositePrimaryKeys::ActiveRecord::QueryMethods
+
+    def destroy(id_or_array)
+      # Without CPK:
+      #if id.is_a?(Array)
+      #  id.map { |one_id| destroy(one_id) }
+      #else
+      #  find(id).destroy
+      #end
+
+      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
+        [id_or_array]
+      else
+        Array(id_or_array)
+      end
+
+      id_or_array.each do |id|
+        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
+          record.destroy
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -1,11 +1,11 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractAdapter
-      def quote_column_names(name)
-        Array(name).map do |col|
-          quote_column_name(col.to_s)
-        end.to_composite_keys.to_s
-      end
-    end
-  end
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def quote_column_names(name)
+        Array(name).map do |col|
+          quote_column_name(col.to_s)
+        end.to_composite_keys.to_s
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/connection_adapters/postgresql/database_statements.rb

@@ -1,26 +1,26 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module PostgreSQL
-      module DatabaseStatements
-        def sql_for_insert(sql, pk, binds) # :nodoc:
-          if pk.nil?
-            # Extract the table from the insert sql. Yuck.
-            table_ref = extract_table_ref_from_insert_sql(sql)
-            pk = primary_key(table_ref) if table_ref
-          end
-
-          # CPK
-          # if pk = suppress_composite_primary_key(pk)
-          #  sql = "#{sql} RETURNING #{quote_column_name(pk)}"
-          #end
-          # NOTE pk can be false.
-          if pk
-            sql = "#{sql} RETURNING #{quote_column_names(pk)}"
-          end
-
-          super
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module DatabaseStatements
+        def sql_for_insert(sql, pk, binds) # :nodoc:
+          if pk.nil?
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          # CPK
+          # if pk = suppress_composite_primary_key(pk)
+          #  sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+          #end
+          # NOTE pk can be false.
+          if pk
+            sql = "#{sql} RETURNING #{quote_column_names(pk)}"
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/counter_cache.rb

@@ -1,15 +1,15 @@
-module ActiveRecord
-  module CounterCache
-    module ClassMethods
-      def update_counters(id, counters)
-        # CPK
-        if self.composite?
-          predicate = cpk_id_predicate(self.arel_table, primary_key, id)
-          unscoped.where!(predicate).update_counters(counters)
-        else
-          unscoped.where!(primary_key => id).update_counters(counters)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module CounterCache
+    module ClassMethods
+      def update_counters(id, counters)
+        # CPK
+        if self.composite?
+          predicate = cpk_id_predicate(self.arel_table, primary_key, id)
+          unscoped.where!(predicate).update_counters(counters)
+        else
+          unscoped.where!(primary_key => id).update_counters(counters)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,21 +1,21 @@
-module ActiveRecord
-  class Fixture
-    def find
-      raise FixtureClassNotFound, "No class attached to find." unless model_class
-      model_class.unscoped do
-        # CPK
-        #model_class.find(fixture[model_class.primary_key])
-        ids = self.ids(model_class.primary_key)
-        model_class.find(ids)
-      end
-    end
-
-    def ids(key)
-      if key.is_a? Array
-        key.map {|a_key| fixture[a_key.to_s] }
-      else
-        fixture[key]
-      end
-    end
-  end
-end
+module ActiveRecord
+  class Fixture
+    def find
+      raise FixtureClassNotFound, "No class attached to find." unless model_class
+      model_class.unscoped do
+        # CPK
+        #model_class.find(fixture[model_class.primary_key])
+        ids = self.ids(model_class.primary_key)
+        model_class.find(ids)
+      end
+    end
+
+    def ids(key)
+      if key.is_a? Array
+        key.map {|a_key| fixture[a_key.to_s] }
+      else
+        fixture[key]
+      end
+    end
+  end
+end