composite_primary_keys 12.0.5 → 13.0.0

data/lib/composite_primary_keys/active_model/attribute_assignment.rb

@@ -1,19 +1,19 @@
-module ActiveModel
-  module AttributeAssignment
-    def _assign_attribute(k, v)
-      # CPK. This is super ugly, but if a table has a composite key where one of the fields is named :id we need
-      # to handle it as a single value. Otherwise, we would call the id=(value) method which is expecting
-      # and array of values.
-      if k == 'id' && self.kind_of?(ActiveRecord::Base) && self.composite? && !self.column_for_attribute(k).null
-        self._write_attribute(k, v)
-      else
-        setter = :"#{k}="
-        if respond_to?(setter)
-          public_send(setter, v)
-        else
-          raise UnknownAttributeError.new(self, k)
-        end
-      end
-    end
-  end
-end
+module ActiveModel
+  module AttributeAssignment
+    def _assign_attribute(k, v)
+      # CPK. This is super ugly, but if a table has a composite key where one of the fields is named :id we need
+      # to handle it as a single value. Otherwise, we would call the id=(value) method which is expecting
+      # and array of values.
+      if k == 'id' && !v.kind_of?(Array) && self.kind_of?(ActiveRecord::Base) && self.composite? && !self.column_for_attribute(k).null
+        self._write_attribute(k, v)
+      else
+        setter = :"#{k}="
+        if respond_to?(setter)
+          public_send(setter, v)
+        else
+          raise UnknownAttributeError.new(self, k)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,69 +1,67 @@
-module ActiveRecord
-  module Associations
-    class AssociationScope
-      def self.get_bind_values(owner, chain)
-        binds = []
-        last_reflection = chain.last
-
-        # CPK
-        # binds << last_reflection.join_id_for(owner)
-        values = last_reflection.join_id_for(owner)
-        binds += Array(values)
-
-        if last_reflection.type
-          binds << owner.class.polymorphic_name
-        end
-
-        chain.each_cons(2).each do |reflection, next_reflection|
-          if reflection.type
-            binds << next_reflection.klass.polymorphic_name
-          end
-        end
-        binds
-      end
-
-      def last_chain_scope(scope, reflection, owner)
-        join_keys = reflection.join_keys
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        table = reflection.aliased_table
-
-        # CPK
-        # value = transform_value(owner[foreign_key])
-        # scope = apply_scope(scope, table, key, value)
-        Array(key).zip(Array(foreign_key)).each do |a_join_key, a_foreign_key|
-          value = transform_value(owner[a_foreign_key])
-          scope = apply_scope(scope, table, a_join_key, value)
-        end
-
-        if reflection.type
-          polymorphic_type = transform_value(owner.class.polymorphic_name)
-          scope = apply_scope(scope, table, reflection.type, polymorphic_type)
-        end
-
-        scope
-      end
-
-      def next_chain_scope(scope, reflection, next_reflection)
-        join_keys = reflection.join_keys
-        key = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        table = reflection.aliased_table
-        foreign_table = next_reflection.aliased_table
-
-        # CPK
-        # constraint = table[key].eq(foreign_table[foreign_key])
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-
-        if reflection.type
-          value = transform_value(next_reflection.klass.polymorphic_name)
-          scope = apply_scope(scope, table, reflection.type, value)
-        end
-
-        scope.joins!(join(foreign_table, constraint))
-      end
-    end
-  end
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        # CPK
+        # binds << last_reflection.join_id_for(owner)
+        values = last_reflection.join_id_for(owner)
+        binds += Array(values)
+
+        if last_reflection.type
+          binds << owner.class.polymorphic_name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.polymorphic_name
+          end
+        end
+        binds
+      end
+
+      def last_chain_scope(scope, reflection, owner)
+        key = reflection.join_primary_key
+        foreign_key = reflection.join_foreign_key
+
+        table = reflection.aliased_table
+
+        # CPK
+        # value = transform_value(owner[foreign_key])
+        # scope = apply_scope(scope, table, key, value)
+        Array(key).zip(Array(foreign_key)).each do |a_join_key, a_foreign_key|
+          value = transform_value(owner[a_foreign_key])
+          scope = apply_scope(scope, table, a_join_key, value)
+        end
+
+        if reflection.type
+          polymorphic_type = transform_value(owner.class.polymorphic_name)
+          scope = apply_scope(scope, table, reflection.type, polymorphic_type)
+        end
+
+        scope
+      end
+
+      def next_chain_scope(scope, reflection, next_reflection)
+        key = reflection.join_primary_key
+        foreign_key = reflection.join_foreign_key
+
+        table = reflection.aliased_table
+        foreign_table = next_reflection.aliased_table
+
+        # CPK
+        # constraint = table[key].eq(foreign_table[foreign_key])
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+        if reflection.type
+          value = transform_value(next_reflection.klass.polymorphic_name)
+          scope = apply_scope(scope, table, reflection.type, value)
+        end
+
+        scope.joins!(join(foreign_table, constraint))
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,103 +1,118 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class Aliases # :nodoc:
-        def column_alias(node, column)
-          # CPK
-          #@alias_cache[node][column]
-          if column.kind_of?(Array)
-            column.map do |a_column|
-              @alias_cache[node][a_column]
-            end
-          else
-            @alias_cache[node][column]
-          end
-        end
-      end
-
-      def instantiate(result_set, &block)
-        primary_key = aliases.column_alias(join_root, join_root.primary_key)
-
-        seen = Hash.new { |i, object_id|
-          i[object_id] = Hash.new { |j, child_class|
-            j[child_class] = {}
-          }
-        }
-
-        model_cache = Hash.new { |h, klass| h[klass] = {} }
-        parents = model_cache[join_root]
-        column_aliases = aliases.column_aliases join_root
-
-        message_bus = ActiveSupport::Notifications.instrumenter
-
-        payload = {
-            record_count: result_set.length,
-            class_name: join_root.base_klass.name
-        }
-
-        message_bus.instrument("instantiation.active_record", payload) do
-          result_set.each { |row_hash|
-            # CPK
-            # parent_key = primary_key ? row_hash[primary_key] : row_hash
-            # CPK
-            parent_key = if primary_key.kind_of?(Array)
-                           primary_key.map {|key| row_hash[key]}
-                         else
-                           primary_key ? row_hash[primary_key] : row_hash
-                         end
-
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, seen, model_cache)
-          }
-        end
-
-        parents.values
-      end
-
-      def construct(ar_parent, parent, row, seen, model_cache)
-        return if ar_parent.nil?
-
-        parent.children.each do |node|
-          if node.reflection.collection?
-            other = ar_parent.association(node.reflection.name)
-            other.loaded!
-          elsif ar_parent.association_cached?(node.reflection.name)
-            model = ar_parent.association(node.reflection.name).target
-            construct(model, node, row, seen, model_cache)
-            next
-          end
-
-          key = aliases.column_alias(node, node.primary_key)
-
-          # CPK
-          if key.is_a?(Array)
-            id = Array(key).map do |column_alias|
-              row[column_alias]
-            end
-            # At least the first value in the key has to be set.  Should we require all values to be set?
-            id = nil if id.first.nil?
-          else # original
-            id = row[key]
-          end
-
-          if id.nil? # duplicating this so it is clear what remained unchanged from the original
-            nil_association = ar_parent.association(node.reflection.name)
-            nil_association.loaded!
-            next
-          end
-
-          model = seen[ar_parent.object_id][node][id]
-
-          if model
-            construct(model, node, row, seen, model_cache)
-          else
-            model = construct_model(ar_parent, node, row, model_cache, id)
-
-            seen[ar_parent.object_id][node][id] = model
-            construct(model, node, row, seen, model_cache)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class Aliases # :nodoc:
+        def column_alias(node, column)
+          # CPK
+          #@alias_cache[node][column]
+          if column.kind_of?(Array)
+            column.map do |a_column|
+              @alias_cache[node][a_column]
+            end
+          else
+            @alias_cache[node][column]
+          end
+        end
+      end
+
+      def instantiate(result_set, strict_loading_value, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }.compare_by_identity
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            # CPK
+            # parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent_key = if primary_key.kind_of?(Array)
+                           primary_key.map {|key| row_hash[key]}
+                         else
+                           primary_key ? row_hash[primary_key] : row_hash
+                         end
+
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
+          }
+        end
+
+        parents.values
+      end
+
+      def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+        return if ar_parent.nil?
+
+        parent.children.each do |node|
+          if node.reflection.collection?
+            other = ar_parent.association(node.reflection.name)
+            other.loaded!
+          elsif ar_parent.association_cached?(node.reflection.name)
+            model = ar_parent.association(node.reflection.name).target
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+            next
+          end
+
+          key = aliases.column_alias(node, node.primary_key)
+          # CPK
+          if key.is_a?(Array)
+            id = Array(key).map do |column_alias|
+              row[column_alias]
+            end
+            # At least the first value in the key has to be set.  Should we require all values to be set?
+            id = nil if id.first.nil?
+          else # original
+            id = row[key]
+          end
+
+          if id.nil?
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
+
+          model = seen[ar_parent][node][id]
+
+          if model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          else
+            model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
+
+            seen[ar_parent][node][id] = model
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods.rb

@@ -1,9 +1,21 @@
-module ActiveRecord
-  module AttributeMethods
-    def has_attribute?(attr_name)
-      # CPK
-      # @attributes.key?(attr_name.to_s)
-      Array(attr_name).all? {|single_attr| @attributes.key?(single_attr.to_s) }
-    end
-  end
-end
+module ActiveRecord
+  module AttributeMethods
+    def has_attribute?(attr_name)
+      # CPK
+      # attr_name = attr_name.to_s
+      # attr_name = self.class.attribute_aliases[attr_name] || attr_name
+      # @attributes.key?(attr_name)
+      Array(attr_name).all? do |attr|
+        attr = attr.to_s
+        attr = self.class.attribute_aliases[attr] || attr
+        @attributes.key?(attr)
+      end
+    end
+
+    def _has_attribute?(attr_name)
+      # CPK
+      # @attributes.key?(attr_name)
+      Array(attr_name).all? { |attr| @attributes.key?(attr) }
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -16,7 +16,6 @@ module ActiveRecord
 
       # Returns the primary key previous value.
       def id_was
-        sync_with_transaction_state
         # CPK
         # attribute_was(self.class.primary_key)
         if self.composite?
@@ -29,7 +28,6 @@ module ActiveRecord
       end
 
       def id_in_database
-        sync_with_transaction_state
         # CPK
         # attribute_in_database(self.class.primary_key)
         if self.composite?

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -1,30 +1,30 @@
-module ActiveRecord
-  module AttributeMethods
-    module Read
-      def read_attribute(attr_name, &block)
-        # CPK
-        # name = attr_name.to_s
-        name = attr_name
-        if self.class.attribute_alias?(name)
-          name = self.class.attribute_alias(name)
-        end
-
-        primary_key = self.class.primary_key
-        # CPK
-        # name = primary_key if name == "id" && primary_key
-        name = primary_key if name == "id" && primary_key && !composite?
-        sync_with_transaction_state if name == primary_key
-        _read_attribute(name, &block)
-      end
-
-      def _read_attribute(attr_name, &block) # :nodoc
-        # CPK
-        if attr_name.kind_of?(Array)
-          attr_name.map {|name| @attributes.fetch_value(name.to_s, &block)}
-        else
-          @attributes.fetch_value(attr_name.to_s, &block)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      def read_attribute(attr_name, &block)
+        # CPK
+        # name = attr_name.to_s
+        name = attr_name
+        if self.class.attribute_alias?(name)
+          name = self.class.attribute_alias(name)
+        end
+
+        primary_key = self.class.primary_key
+        # CPK
+        # name = primary_key if name == "id" && primary_key
+        name = primary_key if name == "id" && primary_key && !composite?
+
+        _read_attribute(name, &block)
+      end
+
+      def _read_attribute(attr_name, &block) # :nodoc
+        # CPK
+        if attr_name.kind_of?(Array)
+          attr_name.map {|name| @attributes.fetch_value(name.to_s, &block)}
+        else
+          @attributes.fetch_value(attr_name.to_s, &block)
+        end
+      end
+    end
+  end
+end