composite_primary_keys 12.0.2 → 12.0.10

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,103 +1,103 @@
-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, &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

data/lib/composite_primary_keys/associations/through_association.rb

@@ -5,7 +5,8 @@ module ActiveRecord
 
       def construct_join_attributes(*records)
         # CPK
-        if source_reflection.klass.composite?
+        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|

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -1,6 +1,19 @@
 module ActiveRecord
   module AttributeMethods
     module PrimaryKey
+      module ClassMethods
+        def suppress_composite_primary_key(pk)
+          pk
+          # return pk unless pk.is_a?(Array)
+          #
+          # warn <<~WARNING
+          #         WARNING: Active Record does not support composite primary key.
+          #
+          #         #{table_name} has composite primary key. Composite primary key is ignored.
+          # WARNING
+        end
+      end
+
       # Returns the primary key previous value.
       def id_was
         sync_with_transaction_state

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?
+        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

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -1,35 +1,35 @@
-module ActiveRecord
-  module AttributeMethods
-    module Write
-      def write_attribute(attr_name, value)
-        # 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
-        _write_attribute(name, value)
-      end
-
-      def _write_attribute(attr_name, value) # :nodoc:
-        # CPK
-        if attr_name.kind_of?(Array)
-          attr_name.each_with_index do |attr_child_name, i|
-            child_value = value ? value[i] : value
-            @attributes.write_from_user(attr_child_name.to_s, child_value)
-          end
-        else
-          @attributes.write_from_user(attr_name.to_s, value)
-        end
-
-        value
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      def write_attribute(attr_name, value)
+        # 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
+        _write_attribute(name, value)
+      end
+
+      def _write_attribute(attr_name, value) # :nodoc:
+        # CPK
+        if attr_name.kind_of?(Array)
+          attr_name.each_with_index do |attr_child_name, i|
+            child_value = value ? value[i] : value
+            @attributes.write_from_user(attr_child_name.to_s, child_value)
+          end
+        else
+          @attributes.write_from_user(attr_name.to_s, value)
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods.rb

@@ -1,9 +1,9 @@
-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
+      # @attributes.key?(attr_name.to_s)
+      Array(attr_name).all? {|single_attr| @attributes.key?(single_attr.to_s) }
+    end
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -1,130 +1,141 @@
-module ActiveRecord
-  class CompositeKeyError < StandardError #:nodoc:
-  end
-
-  class Base
-    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
-
-    class << self
-      alias_method :primary_key_without_composite_key_support=, :primary_key=
-      def primary_key=(keys)
-        unless keys.kind_of?(Array)
-          self.primary_key_without_composite_key_support = keys
-          return
-        end
-
-        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
-
-        class_eval <<-EOV
-          extend  CompositeClassMethods
-          include CompositeInstanceMethods
-        EOV
-      end
-      alias_method :primary_keys=, :primary_key=
-
-      def set_primary_keys(*keys)
-        ActiveSupport::Deprecation.warn(
-            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
-        )
-
-        keys = keys.first if keys.first.is_a?(Array)
-        if keys.length == 1
-          self.primary_key = keys.first
-        else
-          self.primary_keys = keys
-        end
-      end
-
-      def composite?
-        false
-      end
-    end
-
-    def composite?
-      self.class.composite?
-    end
-
-    module CompositeClassMethods
-      def primary_keys
-        @primary_keys = reset_primary_keys unless defined? @primary_keys
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys #:nodoc:
-        if self == base_class
-          # CPK
-          self.primary_keys = get_primary_key(base_class.name)
-        else
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key
-        primary_keys
-      end
-
-      def primary_key=(keys)
-        self.primary_keys = keys
-      end
-
-      def composite?
-        true
-      end
-
-      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
-      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
-      end
-    end
-
-    module CompositeInstanceMethods
-      # A model instance's primary keys is always available as model.ids
-      # whether you name it the default 'id' or set it to something else.
-      def id
-        attr_names = self.class.primary_keys
-        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
-      end
-      alias_method :ids, :id
-
-      def ids_hash
-        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
-          hash[key] = value
-          hash
-        end
-      end
-
-      def id_before_type_cast
-        self.class.primary_keys.map do |key|
-          self.read_attribute_before_type_cast(key)
-        end
-      end
-
-      # Sets the primary ID.
-      def id=(ids)
-        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
-        unless ids.length == self.class.primary_keys.length
-          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
-        end
-        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
-        id
-      end
-
-      def can_change_primary_key_values?
-        false
-      end
-
-      # Returns this record's primary keys values in an Array
-      # if any value is available
-      def to_key
-        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
-      end
-
-      def to_param
-        persisted? ? to_key.to_composite_keys.to_s : nil
-      end
-    end
-  end
-end
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
+
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
+    class << self
+      alias_method :primary_key_without_composite_key_support=, :primary_key=
+      def primary_key=(keys)
+        unless keys.kind_of?(Array)
+          self.primary_key_without_composite_key_support = keys
+          return
+        end
+
+        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
+
+        class_eval <<-EOV
+          extend  CompositeClassMethods
+          include CompositeInstanceMethods
+        EOV
+      end
+      alias_method :primary_keys=, :primary_key=
+
+      def set_primary_keys(*keys)
+        ActiveSupport::Deprecation.warn(
+            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
+        )
+
+        keys = keys.first if keys.first.is_a?(Array)
+        if keys.length == 1
+          self.primary_key = keys.first
+        else
+          self.primary_keys = keys
+        end
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    def composite?
+      self.class.composite?
+    end
+
+    module CompositeClassMethods
+      def primary_keys
+        @primary_keys = reset_primary_keys unless defined? @primary_keys
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys #:nodoc:
+        if self == base_class
+          # CPK
+          self.primary_keys = get_primary_key(base_class.name)
+        else
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
+      def primary_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        self.primary_keys = keys
+      end
+
+      def composite?
+        true
+      end
+
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
+      end
+    end
+
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
+
+      # This is overridden purely for json serialization support. If the model is composite
+      # and one of the keys is id, then we don't want to call the id method, instead we want
+      # to get the id attribute value
+      def read_attribute_for_serialization(attribute)
+        if self.composite? && attribute == 'id'
+          read_attribute(attribute)
+        else
+          send(attribute)
+        end
+      end
+
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+
+      def id_before_type_cast
+        self.class.primary_keys.map do |key|
+          self.read_attribute_before_type_cast(key)
+        end
+      end
+
+      # Sets the primary ID.
+      def id=(ids)
+        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
+        unless ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
+        end
+        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
+
+      def can_change_primary_key_values?
+        false
+      end
+
+      # Returns this record's primary keys values in an Array
+      # if any value is available
+      def to_key
+        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
+      end
+
+      def to_param
+        persisted? ? to_key.to_composite_keys.to_s : nil
+      end
+    end
+  end
+end