composite_primary_keys 7.0.16 → 8.0.0

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -1,19 +1,19 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class BelongsTo
-        def query_scope(ids)
-          # CPK
-          # scope.where(association_key.in(ids))
-
-          if association_key_name.is_a?(Array)
-            predicate = cpk_in_predicate(table, association_key_name, ids)
-            scope.where(predicate)
-          else
-            scope.where(association_key.in(ids))
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo
+        def query_scope(ids)
+          # CPK
+          # scope.where(association_key.in(ids))
+
+          if association_key_name.is_a?(Array)
+            predicate = cpk_in_predicate(table, association_key_name, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/singular_association.rb

@@ -0,0 +1,15 @@
+module CompositePrimaryKeys
+  module SingularAssociation
+    extend ActiveSupport::Concern
+    included do
+      def get_records_with_cpk_support
+        cpk_applies = (target && target.composite?) || (owner && owner.composite?)
+        return scope.limit(1).to_a if cpk_applies
+        get_records_without_cpk_support
+      end
+      alias_method_chain :get_records, :cpk_support
+    end
+  end
+end
+
+ActiveRecord::Associations::SingularAssociation.send(:include, CompositePrimaryKeys::SingularAssociation)

data/lib/composite_primary_keys/attribute_methods.rb

@@ -0,0 +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

data/lib/composite_primary_keys/attribute_methods/dirty.rb

@@ -1,26 +1,29 @@
-module ActiveRecord
-  module AttributeMethods
-    module Dirty
-      def write_attribute(attr, value)
-        # CPK
-        if attr.kind_of?(Array)
-          # A *composite* attribute can't be marked as changed! So do nothing now.
-          # We will come back in here with an *individual* attribute when Write#write_attribute looks through the individual attributes comprising this composite key:
-          # [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-        else
-          attr = attr.to_s
-
-          save_changed_attribute(attr, value)
-        end
-
-        # Carry on.
-        super(attr, value)
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  alias :[]= :write_attribute
-  public :[]=
-end
+module ActiveRecord
+  module AttributeMethods
+    module Dirty
+      def write_attribute(attr, value)
+        # CPK
+        if attr.kind_of?(Array)
+          # A *composite* attribute can't be marked as changed! So do nothing now.
+          # We will come back in here with an *individual* attribute when Write#write_attribute looks through the individual attributes comprising this composite key:
+          value = [nil] * attr.length if value.nil?
+          [attr, value].transpose.map {|name,val| write_attribute(name, val)}
+        else
+          attr = attr.to_s
+
+          old_value = old_attribute_value(attr)
+
+          result = super
+          store_original_raw_attribute(attr)
+          save_changed_attribute(attr, old_value)
+          result
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  alias :[]= :write_attribute
+  public :[]=
+end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -1,35 +1,20 @@
-module ActiveRecord
-  module AttributeMethods
-    module Read
-      def read_attribute(attr_name)
-        if attr_name.kind_of?(Array)
-          attr_name.map {|name| read_attribute(name)}.to_composite_keys
-        else
-          # If it's cached, just return it
-          # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
-          name = attr_name.to_s
-          @attributes_cache[name] || @attributes_cache.fetch(name) {
-            column = @column_types_override[name] if @column_types_override
-            column ||= @column_types[name]
-
-            return @attributes.fetch(name) {
-              if name == 'id' && self.class.primary_key != name
-                read_attribute(self.class.primary_key)
-              end
-            } unless column
-
-            value = @attributes.fetch(name) {
-              return block_given? ? yield(name) : nil
-            }
-
-            if self.class.cache_attribute?(name)
-              @attributes_cache[name] = column.type_cast(value)
-            else
-              column.type_cast value
-            end
-          }
-        end
-      end
-    end
-  end
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      def read_attribute(attr_name, &block)
+        # CPK
+        # name = attr_name.to_s
+        # name = self.class.primary_key if name == 'id'
+        # @attributes.fetch_value(name, &block)
+        
+        if attr_name.kind_of?(Array)
+          attr_name.map {|name| read_attribute(name)}.to_composite_keys
+        else
+          name = attr_name.to_s
+          name = self.class.primary_key if name == 'id' && !composite?
+          @attributes.fetch_value(name, &block)
+        end
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -1,36 +1,30 @@
-module ActiveRecord
-  module AttributeMethods
-    module Write
-      def write_attribute_with_type_cast(attr_name, value, type_cast_method)
-        # CPK
-        if attr_name.kind_of?(Array)
-          value = [nil]*attr_name.length if value.nil?
-          unless value.length == attr_name.length
-            raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
-          end
-          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-          value
-        else
-          attr_name = attr_name.to_s
-          # CPK
-          # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
-          @attributes_cache.delete(attr_name)
-          column = column_for_attribute(attr_name)
-
-          # If we're dealing with a binary column, write the data to the cache
-          # so we don't attempt to typecast multiple times.
-          if column && column.binary?
-            @attributes_cache[attr_name] = value
-          end
-
-          if column || @attributes.has_key?(attr_name)
-            @attributes[attr_name] = send(type_cast_method, column, value)
-          else
-            raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
+        # CPK
+        if attr_name.kind_of?(Array)
+          value = [nil]*attr_name.length if value.nil?
+          unless value.length == attr_name.length
+            raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
+          end
+          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+          value
+        else
+          attr_name = attr_name.to_s
+          # CPK
+          # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
+
+          if should_type_cast
+            @attributes.write_from_user(attr_name, value)
+          else
+            @attributes.write_from_database(attr_name, value)
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_set/builder.rb

@@ -0,0 +1,20 @@
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      def build_from_database(values = {}, additional_types = {})
+        # CPK
+        # if always_initialized && !values.key?(always_initialized)
+        #   values[always_initialized] = nil
+        # end
+        Array(always_initialized).each do |always_initialized_attribute|
+          if always_initialized_attribute && !values.key?(always_initialized_attribute)
+            values[always_initialized_attribute] = nil
+          end
+        end
+        
+        attributes = LazyAttributeHash.new(types, values, additional_types)
+        AttributeSet.new(attributes)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -1,129 +1,135 @@
-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
-      def primary_keys
-        unless defined?(@primary_keys)
-          reset_primary_keys
-        end
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys
-        if self != base_class
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key_with_composite_key_support=(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_chain :primary_key=, :composite_key_support
-      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_key
-        primary_keys
-      end
-
-      def primary_key=(keys)
-        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.send("#{key.to_s}_before_type_cast")
-        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.join(CompositePrimaryKeys::ID_SEP) : 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
+      def primary_keys
+        unless defined?(@primary_keys)
+          reset_primary_keys
+        end
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys
+        if self != base_class
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
+      def primary_key_with_composite_key_support=(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_chain :primary_key=, :composite_key_support
+      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_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        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.send("#{key.to_s}_before_type_cast")
+        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 ==(comparison_object)
+        return false if !persisted? && comparison_object.object_id != object_id
+        return true if equal? comparison_object
+        ids.is_a?(Array) ? super(comparison_object) && ids.all? {|id| !id.nil?} : super(comparison_object)
+      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.join(CompositePrimaryKeys::ID_SEP) : nil
+      end
+    end
+  end
+end